Bem-vindo ao Curso de Lógica e Algoritmos
Desenvolva o pensamento computacional e domine as bases da programação!
🎯 Sobre o Curso
Este curso foi desenvolvido para quem deseja iniciar na área de desenvolvimento de software. Você aprenderá desde a lógica de programação, construção de algoritmos, até a implementação em diversas linguagens de mercado.
O que você vai aprender: - Fundamentos da Lógica de Programação - Estruturas de Controle (Sequencial, Condicional, Repetição) - Estruturas de Dados (Vetores e Matrizes) - Modularização com Funções - Introdução Prática a 8 Linguagens (C, C++, Java, C#, Python, JS, Rust, Dart)
🚀 Comece Agora
-
Aulas
16 aulas completas organizadas em fundamentos e linguagens.
-
Slides
Slides interativos para acompanhar cada aula.
-
Exercícios
Pratique com exercícios focados em cada tópico.
-
Quizzes
Teste seus conhecimentos com quizzes rápidos.
-
Projetos
Projetos práticos para consolidar o aprendizado.
-
Configuração
Guias de instalação das ferramentas (VisualG, Portugol Studio, Compiladores).
📚 Estrutura do Curso
O curso está organizado em 2 módulos principais:
- Fundamentos da Lógica (Aulas 01-08)
- Conceitos, Algoritmos, Estruturas de Controle e Dados.
- Introdução às Linguagens (Aulas 09-16)
- Aplicação da lógica em C, C++, Java, C#, Python, JavaScript, Rust e Dart.
🎓 Como Usar Este Curso
- Configure seu ambiente - Siga os guias de configuração
- Siga a ordem - Comece pela Aula 01 e avance progressivamente
- Pratique muito - A prática leva à perfeição!
- Implemente os Projetos - Aplique o que aprendeu em cenários reais
Pronto para começar? Ir para Aula 01
Sobre o Curso
🎓 Git e GitHub - Do Zero ao Profissional
Este é um curso completo e estruturado de Versionamento de Código com Git e GitHub. Desenvolvido para levar você do básico ao avançado, com uma abordagem prática e focada nas necessidades reais do mercado de desenvolvimento de software.
🎯 Objetivos do Curso
-
Dominar Git
Aprender os comandos fundamentais, fluxo de trabalho local e como o Git funciona por baixo dos panos.
-
GitHub Profissional
Utilizar o GitHub não apenas como repositório, mas como plataforma de colaboração, gestão de projetos e portfólio.
-
Colaboração
Trabalhar em equipe utilizando Branches, Pull Requests, Code Reviews e resolvendo conflitos de forma eficiente.
-
Boas Práticas
Criar um histórico de commits limpo, escrever mensagens significativas e manter repositórios organizados.
📚 O Que Você Vai Aprender
Módulo 1 – Conceitos Básicos
- Instalação e configuração do Git
- Ciclo de vida dos arquivos (Tracked to Committed)
- Histórico e navegação no tempo
- Ramificação (Branching) e Fusão (Merging)
Módulo 2 – Trabalhando com GitHub
- Repositórios Remotos
- Sincronização (Push/Pull)
- Resolução de Conflitos
- Pull Requests e Code Review
Módulo 3 – Fluxos e Organização
- GitHub Flow
- Issues e Projects (Kanban)
- Markdown para documentação
- README profissional
Módulo 4 – Colaboração e Carreira
- Forks e contribuição Open Source
- GitHub Pages para hospedagem
- Tratamento de erros comuns (Detached HEAD, etc.)
- Construção de portfólio
🛠️ Metodologia
-
Aulas Teóricas
Conteúdo explicativo com exemplos práticos e slides interativos.
-
Exercícios Práticos
Listas de exercícios para fixar o conteúdo de cada aula.
-
Projetos Reais
Desenvolva projetos práticos aplicando os conceitos aprendidos.
-
Quizzes Interativos
Teste seus conhecimentos com quizzes ao final de cada módulo.
👨🎓 Para Quem é Este Curso
- Iniciantes que nunca usaram controle de versão
- Desenvolvedores que usam Git apenas no básico ("add, commit, push")
- Estudantes que precisam organizar seus trabalhos acadêmicos
- Profissionais que querem melhorar seu fluxo de trabalho em equipe
📋 Pré-requisitos
- Computador com Windows, Linux ou macOS
- Instalação do Git (coberta no curso)
- Conta no GitHub (gratuita)
- Não é necessário conhecimento prévio de programação!
🎖️ O Que Você Receberá
- ✅ 16 aulas completas e estruturadas
- ✅ Slides interativos para todas as aulas
- ✅ Exercícios práticos com soluções
- ✅ Projetos reais para portfólio
- ✅ Quizzes para autoavaliação
- ✅ Guias de configuração de ambiente
🚀 Comece Agora
Pronto para dominar o Git?
Ir para Aula 01 Configurar Ambiente
Dúvidas? Entre em contato ou acesse a documentação completa.
Aulas
Aulas do Curso
Bem-vindo à seção de aulas! Aqui você encontra todo o conteúdo do curso organizado por módulos.
📚 Módulos do Curso
-
Módulo 1 – Conceitos Básicos
-
Módulo 2 – Trabalhando com GitHub
-
Módulo 3 – Fluxos e Organização
-
Módulo 4 – Colaboração e Carreira
Fundamentos da Lógica
Aula 01 - Conteúdo do Curso
Este documento apresenta a estrutura completa do curso de formação em algoritmos e desenvolvimento de software.
📚 Conteúdo do Curso
O curso é dividido em duas grandes áreas: a base de lógica de programação com Portugol e a aplicação desses conceitos em linguagens de programação populares no mercado.
Algoritmos e Lógica de Programação (Portugol e VisualG)
Nesta primeira parte, o foco é construir uma base sólida em lógica, essencial para qualquer desenvolvedor.
- Apresentação do curso: Objetivos, metodologia e visão geral do conteúdo.
- Conceitos de programação: O que são algoritmos, variáveis, tipos de dados e operadores.
- Estrutura sequencial: Execução de comandos passo a passo.
- Estrutura condicional: Uso de
se-entao-senaopara criar fluxos de decisão. - Estruturas repetitivas: Comandos de repetição como
enquanto,paraerepita-ate. - Vetores: Manipulação de listas de dados unidimensionais.
- Matrizes: Trabalho com tabelas e estruturas de dados bidimensionais.
Linguagens de Programação
Com a base lógica consolidada, o curso avança para a implementação em linguagens modernas.
- Instalação das ferramentas: Configuração de ambientes de desenvolvimento como VS Code, IntelliJ IDEA, PyCharm e outros.
- Linguagem C: Uma linguagem estruturada fundamental para entender o funcionamento de baixo nível.
- Linguagem C++: Evolução do C com suporte à programação orientada a objetos.
- Linguagem Java: Foco em portabilidade e orientação a objetos para sistemas robustos.
- Linguagem C#: A solução da Microsoft para desenvolvimento de aplicações web, desktop e jogos.
- Linguagem Python: Sintaxe limpa e ecossistema rico para ciência de dados, web e automação.
🚀 Percurso de Formação
O percurso de aprendizado foi desenhado para garantir uma progressão lógica e consistente, do teórico ao prático.
- Fundamentos: Inicia-se com o estudo de Algoritmos e Lógica de Programação (Capítulos 1 a 7), construindo a base do pensamento computacional.
- Configuração do Ambiente: Em seguida, realiza-se a instalação das ferramentas de desenvolvimento (Capítulo 8), como VS Code, PyCharm, IntelliJ IDEA e Visual Studio.
- Aplicação Prática: Por fim, o aluno pode escolher ou seguir a sequência de linguagens para aplicar os conhecimentos adquiridos:
- Linguagem C (Capítulo 9)
- Linguagem C++ (Capítulo 10)
- Linguagem Java (Capítulo 11)
- Linguagem C# (Capítulo 12)
- Linguagem Python (Capítulo 13)
🚀 ricardotecpro.github.io
🎓 Introdução à Programação
Este guia aborda os conceitos fundamentais da programação, desde a definição de um algoritmo até as ferramentas necessárias para criar seu primeiro programa.
🤖 Algoritmo, Automação e Programas
O que é um Algoritmo? 🤔
Um algoritmo é uma sequência finita e lógica de instruções para resolver um problema específico. Embora o termo seja muito comum em computação, ele se aplica a diversas outras áreas do conhecimento.
Pense em uma receita de bolo 🎂: ela é um algoritmo. Você segue passos definidos (misturar ingredientes, assar por 30 minutos) para chegar a um resultado esperado.
Exemplo prático: Lavar roupa 🧺
Para o problema "lavar roupa suja", um algoritmo simples seria:
- Colocar a roupa em um recipiente (como uma máquina de lavar).
- Adicionar sabão e amaciante.
- Encher com água.
- Deixar de molho por 20 minutos.
- Esfregar a roupa (ou deixar a máquina fazer isso).
- Enxaguar para remover o sabão.
- Torcer para retirar o excesso de água.
graph TD
A[Início: Roupa Suja] --> B{Colocar na Máquina};
B --> C[Adicionar Sabão/Amaciante];
C --> D[Encher com Água];
D --> E["Deixar de Molho (20 min)"];
E --> F["Esfregar/Lavar (Máquina)"];
F --> G[Enxaguar];
G --> H[Torcer];
H --> I[Estender no Varal];
I --> J[Recolher Roupa Seca];
J --> K[Dobrar e Guardar];
K --> L[Fim: Roupa Limpa];O que é Automação? ⚙️
Automação é o processo de usar máquinas para executar as tarefas de um algoritmo de forma automática ou semiautomática. Usar uma máquina de lavar, por exemplo, automatiza quase todo o algoritmo de lavar roupas.
A Relação com Computadores 💻
O computador é a principal ferramenta de automação para o processamento de informações. Ele é composto por duas partes:
- Hardware: A parte física, ou seja, a máquina em si (processador, memória, tela, teclado).
- Software: A parte lógica, que são os programas e dados, incluindo o Sistema Operacional e os aplicativos.
Um programa de computador é um algoritmo escrito de forma que o computador consiga entender e executar, automatizando a solução de um problema.
Contudo, computadores são especializados em algoritmos computacionais, que envolvem principalmente o processamento de dados e cálculos matemáticos.
🛠️ Ferramentas Essenciais para Programar
Para criar um programa de computador, você precisará de algumas ferramentas básicas:
- Linguagem de Programação: Um conjunto de regras para escrever as instruções que o computador seguirá.
- IDE (Ambiente de Desenvolvimento Integrado): Um software que facilita a escrita, o teste e a depuração do código.
- Compilador ou Interpretador: Um programa que "traduz" seu código para a linguagem que a máquina entende.
📜 Linguagens de Programação
Uma linguagem de programação possui regras léxicas (ortografia das palavras) e sintáticas (gramática das frases).
- Léxica: Refere-se à grafia correta das palavras. Exemplo:
mainestá correto,maimestá incorreto. - Sintática: Refere-se à organização correta das palavras. Exemplo:
x = 10 + y;está correto,x = + 10 y;está incorreto.
Existem muitas linguagens populares, como: C, C++, Java, C#, Python, Ruby, PHP e JavaScript.
📝 Exemplo 1: Média de Notas
Este programa solicita o nome e duas notas de um aluno e, em seguida, calcula e exibe a média.
Solução em Linguagem C
#include <stdio.h>
int main() {
char nome[50];
double nota1, nota2, media;
printf("Digite o nome do aluno: ");
scanf("%s", nome);
printf("Digite a primeira nota: ");
scanf("%lf", ¬a1);
printf("Digite a segunda nota: ");
scanf("%lf", ¬a2);
media = (nota1 + nota2) / 2.0;
printf("A média do(a) aluno(a) %s é: %.2f\n", nome, media);
return 0;
}
Solução em Linguagem Java ☕
import java.util.Locale;
import java.util.Scanner;
public class Programa {
public static void main(String[] args) {
Locale.setDefault(Locale.US);
Scanner sc = new Scanner(System.in);
String nome;
double nota1, nota2, media;
System.out.print("Digite o nome do aluno: ");
nome = sc.nextLine();
System.out.print("Digite a primeira nota: ");
nota1 = sc.nextDouble();
System.out.print("Digite a segunda nota: ");
nota2 = sc.nextDouble();
media = (nota1 + nota2) / 2.0;
System.out.printf("A média do(a) aluno(a) %s é: %.2f\n", nome, media);
sc.close();
}
}
📝 Exemplo 2: Área de um Retângulo
Este programa calcula a área de um retângulo com base nos valores de base e altura fornecidos.
Solução em Linguagem C++
#include <iostream>
#include <iomanip>
int main() {
double base, altura, area;
std::cout << "Digite o valor da base: ";
std::cin >> base;
std::cout << "Digite o valor da altura: ";
std::cin >> altura;
area = base * altura;
std::cout << "A área do retângulo é: " << std::fixed << std::setprecision(2) << area << std::endl;
return 0;
}
Saída Esperada:
Solução em Linguagem C# 💎
using System;
using System.Globalization;
namespace Curso {
class Programa {
static void Main(string[] args) {
double baseRet, altura, area;
Console.Write("Digite o valor da base: ");
baseRet = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
Console.Write("Digite o valor da altura: ");
altura = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
area = baseRet * altura;
Console.WriteLine("A área do retângulo é: " + area.ToString("F2", CultureInfo.InvariantCulture));
}
}
}
Saída Esperada:
💻 IDEs (Ambientes de Desenvolvimento Integrado)
Uma IDE é um programa que reúne diversas ferramentas para facilitar a vida do desenvolvedor. Funcionalidades comuns incluem edição de código avançada, depuração (debugging) e automação de compilação.
IDEs Populares por Linguagem:
- Java: IntelliJ IDEA e VS Code (com o Extension Pack for Java).
- C#: Microsoft Visual Studio e VS Code (com a extensão C#).
- C/C++: VS Code (com extensões C/C++) e CLion.
⚙️ Compilação vs. Interpretação
Para que um computador execute um programa, o código-fonte (o que você escreve) precisa ser traduzido. Existem três abordagens principais:
1. Compilação
Um Compilador traduz todo o código-fonte de uma vez, gerando um código executável.
- Vantagens: Execução muito rápida 🚀.
- Linguagens Típicas: C, C++.
2. Interpretação
Um Interpretador lê e executa o código-fonte linha por linha.
- Vantagens: Mais flexível, o mesmo código roda em qualquer plataforma 🌐.
- Linguagens Típicas: PHP, JavaScript, Python, Ruby.
3. Abordagem Híbrida
O código-fonte é pré-compilado para um código intermediário chamado Bytecode, que é então interpretado por uma Máquina Virtual (VM).
- Vantagens: Portabilidade e bom desempenho.
- Linguagens Típicas: Java (com a JVM), C# (com o .NET).
Portugol e Ferramentas de Aprendizagem
Para focar no aprendizado da lógica do algoritmo sem a complexidade de uma linguagem real, utiliza-se o Portugol. É uma pseudo-linguagem didática com sintaxe simplificada e em português.
Atenção: Portugol é uma linguagem para aprender, não para criar programas comerciais.
Existem IDEs simples para escrever e testar algoritmos em Portugol:
- VisualG: Uma ferramenta clássica e leve.
- Portugol Studio: Uma alternativa mais moderna e com mais recursos. Você pode encontrá-lo em
portugol.dev.
Exemplo em VisualG
algoritmo "CalculoMedia"
// Área de declaração de variáveis
var
nome: caractere
nota1, nota2, media: real
// Corpo do algoritmo
inicio
escreval("Digite o nome do aluno: ")
leia(nome)
escreval("Digite a primeira nota: ")
leia(nota1)
escreval("Digite a segunda nota: ")
leia(nota2)
media <- (nota1 + nota2) / 2
escreval("A média do(a) aluno(a) ", nome, " é: ", media)
fimalgoritmo
As principais diferenças são a estrutura do programa (programa { ... }), a declaração de variáveis dentro da função e o operador de atribuição (= em vez de <-).
Exemplo em Portugol Studio
programa
{
// A função 'inicio' é o ponto de entrada do programa.
funcao inicio()
{
// Área de declaração de variáveis
cadeia nome
real nota1, nota2, media
// Corpo do algoritmo (Entrada, Processamento e Saída de Dados)
escreva("Digite o nome do aluno(a): ")
leia(nome)
escreva("Digite a primeira nota: ")
leia(nota1)
escreva("Digite a segunda nota: ")
leia(nota2)
// Processamento: calcula a média
media = (nota1 + nota2) / 2
// Saída: exibe o resultado formatado
escreva("\nA média do(a) aluno(a) ", nome, " é: ", media)
}
}
Principais Mudanças e Explicações:
- Estrutura: O Portugol Studio usa uma estrutura de blocos com chaves
{}. O programa inteiro é envolvido porprograma { ... }. - Função Principal: Todo o código executável deve estar dentro da função
funcao inicio() { ... }. - Declaração de Variáveis: As variáveis são declaradas no início da função onde serão usadas, não em um bloco
varseparado. - Tipos de Dados: O tipo
caracteredo VisualG corresponde ao tipocadeiano Portugol Studio. O tiporealé o mesmo. - Atribuição: O operador para atribuir um valor a uma variável é o sinal de igual (
=), e não a seta (<-). - Comandos de Escrita: O comando
escrevaldo VisualG é equivalente aoescrevado Portugol Studio. Ambos pulam uma linha ao final da escrita. O\nfoi adicionado na última linha para dar um espaçamento extra antes da mensagem final, tornando a saída mais legível.
🚀 ricardotecpro.github.io
🚀 Estrutura Sequencial em Programação
Este capítulo aborda os conceitos fundamentais da estrutura sequencial, a base para a construção de qualquer algoritmo. Nela, os comandos são executados em uma sequência lógica, um após o outro, de cima para baixo.
🤔 O que é a Estrutura Sequencial?
A "estrutura sequencial" recebe esse nome para destacar que as instruções de um algoritmo são executadas em uma ordem predefinida, passo a passo. Um algoritmo só funciona corretamente se seus comandos seguirem uma sequência lógica.
Imagine que você precisa calcular a soma de dois números. Primeiro, você precisa conhecer esses números e, só depois, realizar a soma.
Exemplo da ordem correta:
// 1. Atribui o valor 15 à variável x
int x = 15;
// 2. Atribui o valor 25 à variável y
int y = 25;
// 3. Soma x e y e guarda o resultado
int soma = x + y; // Correto!
Se a ordem for invertida, o programa tentará somar variáveis que ainda não têm valor, resultando em um erro.
Exemplo da ordem incorreta:
// 1. Tenta somar x e y, que ainda não foram definidos
int soma = x + y; // Errado!
// 2. Só depois define os valores
int x = 15;
int y = 25;
💻 As Três Operações Fundamentais
Um programa de computador, em sua essência, realiza três operações básicas:
- Entrada de dados: Receber informações do usuário ou de outra fonte.
- Processamento de dados: Realizar cálculos e manipular as informações recebidas.
- Saída de dados: Apresentar os resultados para o usuário.
📦 Variáveis e Tipos de Dados
Para um programa funcionar, ele precisa armazenar e manipular dados. Esses dados são guardados em variáveis.
De forma simplificada, uma variável é um "espaço" na memória RAM do computador reservado para armazenar um dado durante a execução do programa.
📜 Declaração de Variáveis
Cada variável possui:
- Nome (ou identificador): Para que possamos nos referir a ela.
- Tipo: Define que tipo de dado ela pode armazenar (número, texto, etc.).
- Valor: O dado que está armazenado nela.
- Endereço: Sua localização na memória.
Em Java, a sintaxe de declaração é:
🏷️ Nomenclatura de Variáveis (Boas Práticas)
Para manter o código legível e funcional, siga estas regras ao nomear variáveis:
- Não pode começar com dígito: Use uma letra ou o caractere
_. - Não pode ter espaços em branco.
- Não use acentos ou caracteres especiais (como
çou~). - Use o padrão "Camel Case": A primeira palavra começa com letra minúscula e as palavras seguintes começam com maiúscula.
| Errado | Correto |
|---|---|
int 5minutos; |
int cincoMinutos; |
double salário; |
double salario; |
String nome do funcionario; |
String nomeDoFuncionario; |
📊 Tipos de Dados Primitivos em Java
Estes são os tipos de dados mais comuns que você usará:
| Tipo | Descrição | Exemplo de Valor |
| :--- | :--- |
| int | Armazena números inteiros. | 35 |
| double | Armazena números com ponto flutuante (decimais). | 1.75 |
| char | Armazena um único caractere. | 'M' |
| String| Armazena sequências de caracteres (texto). | "Maria da Silva" |
| boolean| Armazena um valor lógico de verdade. | true ou false |
⚙️ Processamento de Dados
O processamento ocorre quando o programa realiza cálculos ou manipula dados. A principal ferramenta para isso é o comando de atribuição, representado pelo sinal de igual (=) em Java.
Sintaxe: <variável> = <expressão>;
A regra é simples:
- A expressão à direita do
=é totalmente calculada. - O resultado final é armazenado na variável à esquerda.
➕ Expressões Aritméticas
São combinações de números, variáveis e operadores que resultam em um valor numérico.
Operadores Aritméticos em Java:
| Operador | Significado |
|---|---|
+ |
Adição |
- |
Subtração |
* |
Multiplicação |
/ |
Divisão |
% |
Módulo (resto da divisão inteira) |
Ordem de Precedência:
*,/,%(são avaliados primeiro, da esquerda para a direita)+,-(são avaliados por último, da esquerda para a direita)
Use parênteses () para forçar uma ordem de cálculo diferente.
Exemplos de Expressões:
5 + 3 * 2→5 + 6→ Resultado: 11(5 + 3) * 2→8 * 2→ Resultado: 1670 / (5 + 2) * 4→70 / 7 * 4→10 * 4→ Resultado: 4015 % 4(15 dividido por 4 dá 3 e sobra 3) → Resultado: 3
🖥️ Saída de Dados
A saída de dados é como o programa apresenta informações e resultados ao usuário, geralmente na tela (console). Em Java, usamos os seguintes comandos:
System.out.println(): Escreve o conteúdo na tela e salta para a próxima linha.System.out.print(): Escreve o conteúdo na tela e permanece na mesma linha.
Exemplo Prático: Ficha de Cadastro
Vamos criar variáveis, atribuir valores e exibi-las de forma organizada.
// Declarando e inicializando as variáveis
String produto1 = "Smartphone";
String produto2 = "Notebook";
double preco1 = 2500.99;
double preco2 = 4250.00;
int idade = 25;
int codigo = 1024;
char genero = 'M';
// Exibindo os dados na tela
System.out.println("Produtos:");
System.out.printf("O produto %s custa R$ %.2f\n", produto1, preco1);
System.out.printf("O produto %s custa R$ %.2f\n", produto2, preco2);
System.out.println(); // Pula uma linha em branco
System.out.println("Código = " + codigo);
System.out.println(); // Pula uma linha em branco
System.out.println("Dados da pessoa: gênero " + genero + " e idade " + idade);
Saída Esperada:
Produtos:
O produto Smartphone custa R$ 2500,99
O produto Notebook custa R$ 4250,00
Código = 1024
Dados da pessoa: gênero M e idade 25
Nota: Usamos
System.out.printf()para formatar os preços com duas casas decimais.%.2fé um especificador que formata um número de ponto flutuante (f) com duas casas decimais (.2), e\nquebra a linha.
⌨️ Entrada de Dados
A entrada de dados permite que o programa se torne interativo, lendo informações digitadas pelo usuário no teclado. Em Java, a forma mais comum de fazer isso é usando a classe Scanner.
Primeiro, você precisa importar a classe e criar um objeto Scanner:
import java.util.Scanner; // Importação necessária
public class Programa {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); // Cria o objeto Scanner
// Agora você pode ler os dados
// ...
sc.close(); // Boa prática: fechar o scanner ao final
}
}
Lendo Diferentes Tipos de Dados
Scanner sc = new Scanner(System.in);
System.out.print("Digite seu nome: ");
String nome = sc.nextLine(); // Lê uma linha de texto
System.out.print("Digite sua idade: ");
int idade = sc.nextInt(); // Lê um número inteiro
System.out.print("Digite seu salário: ");
double salario = sc.nextDouble(); // Lê um número double
System.out.println("DADOS DIGITADOS:");
System.out.println("Nome: " + nome);
System.out.println("Idade: " + idade);
System.out.printf("Salário: R$ %.2f\n", salario);
sc.close();
Atenção: Ao ler um número (
nextIntounextDouble) e depois um texto comnextLine, uma quebra de linha "invisível" pode ser consumida pelonextLine, causando um pulo indesejado. Para corrigir, consuma essa quebra de linha extra com umsc.nextLine()adicional antes de ler o texto.
🧮 Funções Matemáticas em Java
Java oferece a classe Math com diversas funções matemáticas prontas para uso.
| Exemplo em Java | Significado |
|---|---|
A = Math.sqrt(x); |
A variável A recebe a raiz quadrada de x. |
A = Math.pow(x, y); |
A variável A recebe o resultado de x elevado a y. |
A = Math.abs(x); |
A variável A recebe o valor absoluto (positivo) de x. |
A = Math.PI; |
A variável A recebe o valor de Pi (3.14159...). |
Exemplo: Fórmula de Bhaskara
Para calcular as raízes de uma equação de segundo grau ($$ax^2 + bx + c = 0$$), usamos as funções da classe Math.
$$ \Delta = b^2 - 4ac $$ $$ x = \frac{-b \pm \sqrt{\Delta}}{2a} $$
double a = 1.0, b = -3.0, c = -4.0;
double delta = Math.pow(b, 2.0) - 4 * a * c;
double x1 = (-b + Math.sqrt(delta)) / (2.0 * a);
double x2 = (-b - Math.sqrt(delta)) / (2.0 * a);
System.out.println("Delta = " + delta); // Saída: Delta = 25.0
System.out.println("x1 = " + x1); // Saída: x1 = 4.0
System.out.println("x2 = " + x2); // Saída: x2 = -1.0
✍️ Exercícios Práticos Resolvidos em Java
Vamos aplicar tudo o que aprendemos em alguns problemas práticos.
Exercício 1: Cálculo de Área de Terreno
Problema: Fazer um programa que leia a largura e o comprimento de um terreno retangular, e também o valor do metro quadrado. Em seguida, o programa deve mostrar o valor da área do terreno e o valor do preço do terreno, ambos com duas casas decimais.
Fórmulas:
área = largura × comprimentopreço = área × preço do metro quadrado
Solução em Java:
package curso;
import java.util.Locale;
import java.util.Scanner;
public class Terreno {
public static void main(String[] args) {
Locale.setDefault(Locale.US); // Para usar o ponto como separador decimal
Scanner sc = new Scanner(System.in);
System.out.print("Digite a largura do terreno: ");
double largura = sc.nextDouble();
System.out.print("Digite o comprimento do terreno: ");
double comprimento = sc.nextDouble();
System.out.print("Digite o valor do metro quadrado: ");
double valorMetroQuadrado = sc.nextDouble();
double area = largura * comprimento;
double preco = area * valorMetroQuadrado;
System.out.printf("Área do terreno = %.2f\n", area);
System.out.printf("Preço do terreno = %.2f\n", preco);
sc.close();
}
}
Exemplo de Execução:
Digite a largura do terreno: 15.0
Digite o comprimento do terreno: 40.0
Digite o valor do metro quadrado: 500.0
Área do terreno = 600.00
Preço do terreno = 300000.00
Exercício 2: Medidas de um Retângulo
Problema: Fazer um programa para ler as medidas da base e da altura de um retângulo. Em seguida, mostrar o valor da área, do perímetro e da diagonal deste retângulo, com quatro casas decimais.
Fórmulas:
área = base × alturaperímetro = 2 × (base + altura)diagonal = √(base² + altura²)
Solução em Java:
package curso;
import java.util.Locale;
import java.util.Scanner;
public class Retangulo {
public static void main(String[] args) {
Locale.setDefault(Locale.US);
Scanner sc = new Scanner(System.in);
System.out.print("Digite a base do retângulo: ");
double base = sc.nextDouble();
System.out.print("Digite a altura do retângulo: ");
double altura = sc.nextDouble();
double area = base * altura;
double perimetro = 2 * (base + altura);
double diagonal = Math.sqrt(Math.pow(base, 2.0) + Math.pow(altura, 2.0));
System.out.printf("ÁREA = %.4f\n", area);
System.out.printf("PERÍMETRO = %.4f\n", perimetro);
System.out.printf("DIAGONAL = %.4f\n", diagonal);
sc.close();
}
}
Exemplo de Execução:
Digite a base do retângulo: 6.0
Digite a altura do retângulo: 8.0
ÁREA = 48.0000
PERÍMETRO = 28.0000
DIAGONAL = 10.0000
🛠️ Como Executar no VS Code e IntelliJ IDEA
Você pode compilar e executar todos os exemplos de código acima em qualquer uma das IDEs modernas.
No Visual Studio Code
- Instale o Pacote de Extensões para Java: Na aba de Extensões (
Ctrl+Shift+X), procure porExtension Pack for Javada Microsoft e instale-o. - Crie o Arquivo: Crie um novo arquivo com a extensão
.java(ex:Terreno.java). - Cole o Código: Copie e cole um dos exemplos no arquivo.
- Execute: Um botão "Run" aparecerá acima do método
main. Clique nele para compilar e executar o código. A saída aparecerá no terminal integrado.
Na IntelliJ IDEA
- Crie um Novo Projeto: Vá em
File > New > Project. EscolhaJavae a versão do JDK. - Crie uma Nova Classe: Na janela de projeto, clique com o botão direito na pasta
src, vá emNew > Java Classe dê um nome à classe (ex:Retangulo). - Cole o Código: Copie e cole o código correspondente na classe criada.
- Execute: Clique com o botão direito do mouse em qualquer lugar dentro do editor de código e selecione Run 'NomeDaClasse.main()'. A saída aparecerá na aba "Run" na parte inferior da IDE.
🚀 ricardotecpro.github.io
⚖️ Estrutura Condicional em Programação
Após entendermos como os programas executam comandos em sequência, vamos explorar a estrutura condicional. Ela permite que um programa tome decisões, alterando seu fluxo de execução com base em condições específicas. É o que torna os programas "inteligentes" e dinâmicos.
🔍 Expressões Lógicas e Comparativas
Para que uma estrutura condicional funcione, ela precisa avaliar uma condição. O resultado dessa avaliação é sempre um valor lógico: verdadeiro ou falso. Essas condições são construídas com expressões comparativas e lógicas.
Expressões Comparativas
Comparam dois valores e o resultado é sempre um boolean (true ou false).
Operadores Comparativos em Java:
| Operador VisualG | Operador Java | Significado |
|---|---|---|
> |
> |
Maior que |
< |
< |
Menor que |
>= |
>= |
Maior ou igual a |
<= |
<= |
Menor ou igual a |
= |
== |
Igual a (Note a diferença!) |
<> |
!= |
Diferente de |
Exemplos (supondo int x = 10;):
x > 0→ Resultado:truex == 10→ Resultado:truex != 10→ Resultado:false20 <= 15→ Resultado:false
Expressões Lógicas
Combinam duas ou mais expressões comparativas, permitindo criar condições mais complexas.
Operadores Lógicos em Java:
| Operador VisualG | Operador Java | Descrição |
|---|---|---|
E |
&& |
E (AND): Verdadeiro somente se todas as condições forem verdadeiras. |
OU |
|| |
OU (OR): Verdadeiro se pelo menos uma condição for verdadeira. |
NAO |
! |
NÃO (NOT): Inverte o valor da condição (de true para false e vice-versa). |
Operador && (E)
Pense na regra para obter uma habilitação de motorista: você precisa ser aprovado no exame psicotécnico E no exame de legislação E no exame de direção. Se falhar em qualquer um deles, o resultado final é "reprovado". Todas as condições devem ser verdadeiras.
Tabela Verdade (E):
| A | B | A && B |
|---|---|---|
false |
false |
false |
false |
true |
false |
true |
false |
false |
true |
true |
true |
Operador || (OU)
Pense nas vagas de estacionamento preferenciais: você pode usá-las se for idoso(a), OU pessoa com deficiência, OU gestante. Basta atender a uma das condições para ter o direito.
Tabela Verdade (OU):
| A | B | A || B |
| :--- | :--- | :--- |
| false | false | false |
| false | true | true |
| true | false | true |
| true | true | true |
Operador ! (NÃO)
Pense na regra para uma bolsa de estudos: você tem direito se NÃO possuir renda maior que R$ 3.000,00. Este operador inverte o resultado da condição. Se a condição renda > 3000 for verdadeira, !(renda > 3000) será falsa.
Tabela Verdade (NÃO):
| A | !A |
|---|---|
false |
true |
true |
false |
🔀 A Estrutura if-else
É a principal estrutura de controle condicional. Ela permite que um bloco de comandos seja executado somente se uma determinada condição for atendida.
if Simples
Executa um bloco de código se a condição for verdadeira. Se for falsa, o bloco é simplesmente ignorado.
Sintaxe em Java:
if-else Composta
Oferece um caminho alternativo. Se a condição for verdadeira, o bloco if é executado. Caso contrário (else), o bloco else é executado.
Sintaxe em Java:
if (condicao) {
// Bloco de comandos a ser executado
// se a condição for verdadeira.
} else {
// Bloco de comandos a ser executado
// se a condição for falsa.
}
Encadeamento com else if
Para cenários com múltiplas condições (mais de duas possibilidades), podemos encadear várias estruturas if-else.
Exemplo: Saudação baseada na hora do dia
import java.util.Scanner;
public class Saudacao {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Digite a hora atual (0-23): ");
int hora = sc.nextInt();
if (hora < 12) { // se a hora for menor que 12
System.out.println("Bom dia!"); // imprime Bom dia!
} else if (hora < 18) { // senão, se a hora for menor que 18
System.out.println("Boa tarde!"); // imprime Boa tarde!
} else { // senão (para qualquer outra hora >= 18)
System.out.println("Boa noite!"); // imprime Boa noite!
}
sc.close();
}
}
Boa Prática: Repare na indentação (o recuo dos blocos de código). Ela não afeta o funcionamento em Java, mas é fundamental para a legibilidade do código!
🔢 A Estrutura switch-case
Quando temos várias opções de fluxo que dependem do valor de uma única variável, podemos usar a estrutura switch-case como uma alternativa mais limpa e organizada a um longo encadeamento de if-else if.
Problema Exemplo: Ler um número inteiro de 1 a 7 e escrever o dia da semana correspondente.
Solução com switch-case em Java:
import java.util.Scanner;
public class DiaDaSemana {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Digite um número para o dia da semana (1-7): ");
int x = sc.nextInt();
String dia;
switch (x) { // A variável a ser avaliada
case 1: // Se o valor for 1
dia = "Domingo";
break; // Interrompe a execução do switch
case 2: // Se o valor for 2
dia = "Segunda-feira";
break;
case 3:
dia = "Terça-feira";
break;
case 4:
dia = "Quarta-feira";
break;
case 5:
dia = "Quinta-feira";
break;
case 6:
dia = "Sexta-feira";
break;
case 7:
dia = "Sábado";
break;
default: // Equivalente ao "outrocaso", se nenhum caso corresponder
dia = "Valor inválido";
break;
}
System.out.println("Dia da semana: " + dia);
sc.close();
}
}
Importante: O comando
breaké essencial. Sem ele, o código continuaria a executar oscaseseguintes ("fall-through"), o que geralmente não é o comportamento desejado. O blocodefaulté opcional e lida com todos os valores não cobertos peloscase.
✍️ Exercícios Práticos Resolvidos em Java
Exercício 1: Fórmula de Bhaskara com Validação
Problema: Relembrando a fórmula de Bhaskara ($$ax^2 + bx + c = 0$$), precisamos criar um programa que calcule as raízes, mas com duas validações importantes:
- O coeficiente
anão pode ser zero, pois senão não é uma equação do segundo grau. - O valor de delta ($$\Delta = b^2 - 4ac$$) não pode ser negativo, pois não existe raiz quadrada real de número negativo.
O programa deve tratar essas condições antes de tentar calcular as raízes.
Solução em Java:
package curso;
import java.util.Locale;
import java.util.Scanner;
public class Bhaskara {
public static void main(String[] args) {
Locale.setDefault(Locale.US);
Scanner sc = new Scanner(System.in);
System.out.print("Coeficiente a: ");
double a = sc.nextDouble();
System.out.print("Coeficiente b: ");
double b = sc.nextDouble();
System.out.print("Coeficiente c: ");
double c = sc.nextDouble();
if (a == 0) {
System.out.println("Esta não é uma equação de segundo grau!");
} else {
double delta = Math.pow(b, 2.0) - 4.0 * a * c;
if (delta < 0) {
System.out.println("Esta equação não possui raízes reais.");
} else {
double x1 = (-b + Math.sqrt(delta)) / (2.0 * a);
double x2 = (-b - Math.sqrt(delta)) / (2.0 * a);
System.out.printf("X1 = %.4f\n", x1);
System.out.printf("X2 = %.4f\n", x2);
}
}
sc.close();
}
}
Exemplos de Execução:
- Entrada:
a=1,b=0,c=-9→ Saída:X1 = 3.0000,X2 = -3.0000 - Entrada:
a=2,b=9,c=10→ Saída:X1 = -2.0000,X2 = -2.5000 - Entrada:
a=5,b=2,c=3→ Saída:Esta equação não possui raízes reais. - Entrada:
a=0,b=4,c=2→ Saída:Esta não é uma equação de segundo grau!
🚀 ricardotecpro.github.io
🔄 Capítulo: Estruturas Repetitivas
As estruturas repetitivas, também conhecidas como laços ou loops, são um pilar da programação. Elas permitem que um bloco de comandos seja executado várias vezes, seja por um número definido de vezes ou enquanto uma determinada condição for atendida. Vamos explorar as três estruturas principais: "enquanto", "para" e "repita-até".
🔁 Estrutura "Enquanto" (while)
O que é?
[cite_start]A estrutura "enquanto" é um laço de repetição que executa um bloco de comandos continuamente enquanto uma condição específica for verdadeira[cite: 616].
Quando Usar?
[cite_start]É a escolha ideal quando não se sabe previamente a quantidade exata de repetições que o programa precisará executar[cite: 617]. A repetição depende de um evento externo, como a digitação de um valor específico pelo usuário (conhecido como valor de sentinela).
Problema Exemplo
Fazer um programa que lê números inteiros até que um zero seja lido. Ao final, o programa deve mostrar a soma de todos os números digitados (exceto o zero).
Exemplo (Novo)
Sintaxe e Regras
- Regra: Antes de cada repetição, a
<condição>é testada.- [cite_start]Se for verdadeira (V), o bloco de comandos executa, e o fluxo volta para o teste da condição[cite: 626].
- [cite_start]Se for falsa (F), o laço é encerrado, e o programa continua na linha seguinte ao
fimenquanto[cite: 626].
Código em Portugol
algoritmo "SomaComEnquanto"
var
x, soma: inteiro
inicio
soma <- 0
escreva("Digite um numero: ")
leia(x)
enquanto x <> 0 faca
soma <- soma + x
escreva("Digite outro numero: ")
leia(x)
fimenquanto
escreval("SOMA = ", soma)
fimalgoritmo
🔢 Estrutura "Para" (for)
O que é?
[cite_start]A estrutura "para" é um laço de repetição projetado para executar um bloco de comandos por um intervalo de valores predefinido ou um número específico de vezes[cite: 744].
Quando Usar?
[cite_start]É recomendada quando se sabe de antemão a quantidade de repetições necessárias[cite: 745]. É perfeita para tarefas baseadas em contagem.
Problema Exemplo
Fazer um programa que primeiro lê um valor inteiro N e, depois, lê N números inteiros. Ao final, mostra a soma dos N números lidos.
Exemplo (Novo)
Quantos numeros serao digitados? 4
Digite um numero: 10
Digite um numero: 8
Digite um numero: -3
Digite um numero: 5
SOMA = 20
Sintaxe e Regras
para <variável> de <valor_inicial> ate <valor_final> [passo <incremento>] faca
// bloco de comandos
fimpara
- Regras:
- [cite_start]Inicialização: A
<variável>de controle recebe o<valor_inicial>na primeira vez[cite: 756]. - [cite_start]Condição: Se o valor da
<variável>não ultrapassou o<valor_final>, o bloco executa[cite: 758]. Caso contrário, o laço termina. - [cite_start]Incremento: Ao final de cada repetição, a
<variável>é incrementada em 1 (ou pelo valor definido empasso)[cite: 759].
- [cite_start]Inicialização: A
Exemplos de Contagem
Contagem Progressiva
Saída:
Contagem Regressiva
Saída:
🎬 Estrutura "Repita-Até" (do-while)
O que é?
[cite_start]A estrutura "repita-até" é um laço de repetição que executa o bloco de comandos pelo menos uma vez, pois a condição de parada só é verificada no final[cite: 879].
Quando Usar?
É menos comum, mas muito útil em situações onde a ação deve ocorrer ao menos uma vez, como em menus interativos onde se pergunta ao usuário se ele deseja realizar a operação novamente.
Problema Exemplo
Fazer um programa para ler uma temperatura em Celsius e mostrar o equivalente em Fahrenheit. Ao final, perguntar se o usuário deseja repetir (s/n). Caso digite "s", o programa repete.
Fórmula de Conversão
$$F = \frac{9 \times C}{5} + 32$$
Exemplo (Novo)
Digite a temperatura em Celsius: 25.0
Equivalente em Fahrenheit: 77.0
Deseja repetir (s/n)? s
Digite a temperatura em Celsius: 0.0
Equivalente em Fahrenheit: 32.0
Deseja repetir (s/n)? s
Digite a temperatura em Celsius: -5.0
Equivalente em Fahrenheit: 23.0
Deseja repetir (s/n)? n
Sintaxe e Regras
- Regra: O bloco de comandos é executado, e somente depois a
<condição>é testada.- [cite_start]Se for falsa (F), o laço executa novamente[cite: 885].
- [cite_start]Se for verdadeira (V), o laço é encerrado[cite: 885]. (Note que a lógica é o inverso da estrutura
enquanto).
Código em Portugol
algoritmo "ConversorDeTemperatura"
var
C, F: real
resp: caractere
inicio
repita
escreva("Digite a temperatura em Celsius: ")
leia(C)
F <- 9.0 * C / 5.0 + 32.0
escreval("Equivalente em Fahrenheit: ", F:4:1)
escreva("Deseja repetir (s/n)? ")
leia(resp)
ate resp = "n"
fimalgoritmo
🚀 ricardotecpro.github.io
➡️ Vetores (Arrays Unidimensionais) em Programação
Vetores, também conhecidos como arrays unidimensionais, são uma das estruturas de dados mais fundamentais na programação. Eles nos permitem armazenar múltiplos valores em uma única variável, de forma organizada e eficiente.
🤔 O que são Vetores?
Um vetor é uma coleção de dados que possui quatro características principais:
- Indexada: Cada elemento no vetor possui uma posição única, chamada de índice, que é usada para acessá-lo. Os índices são sempre números inteiros, começando em zero.
- Unidimensional: É uma estrutura de dados linear, como uma lista ou uma fila, possuindo apenas uma dimensão (comprimento).
- Homogênea: Todos os elementos armazenados em um vetor devem ser, obrigatoriamente, do mesmo tipo de dado (todos
int, todosdouble, todosString, etc.). - Tamanho Fixo: Uma vez que um vetor é criado na memória, seu tamanho (a quantidade de elementos que ele pode conter) é fixo e não pode ser alterado.
🛠️ Trabalhando com Vetores em Java
Vamos ver como declarar, instanciar (criar) e manipular vetores na linguagem Java.
Declaração e Instanciação
Para usar um vetor, você primeiro o declara e depois o instancia, especificando seu tipo e tamanho.
// Sintaxe: tipo[] nomeDoVetor = new tipo[tamanho];
// Exemplo: Criando um vetor de 10 posições para números de ponto flutuante.
// Isso corresponde a "vet: vetor [0..9] de real" do pseudocódigo.
double[] numeros = new double[10];
// Exemplo: Criando um vetor de 5 posições para armazenar nomes.
String[] nomes = new String[5];
Acessando Elementos
O acesso aos elementos é feito através de seus índices. Lembre-se sempre que o primeiro elemento está no índice 0.
// Atribuindo o valor 25.4 à primeira posição (índice 0) do vetor.
numeros[0] = 25.4;
// Atribuindo o valor "Ana" à terceira posição (índice 2) do vetor.
nomes[2] = "Ana";
// Lendo e imprimindo o valor da terceira posição de 'nomes'.
System.out.println(nomes[2]); // Saída: Ana
Frequentemente, usamos laços de repetição, como o for, para percorrer e manipular todos os elementos de um vetor de forma eficiente.
// Exemplo: Preenchendo um vetor com os números de 10 a 14.
// Equivalente à lógica B[i] <- i + 10.
int[] vetorB = new int[5];
for (int i = 0; i < vetorB.length; i++) {
vetorB[i] = i + 10;
System.out.println("Posição " + i + " recebeu o valor " + vetorB[i]);
}
✍️ Exemplo Prático: Lendo e Imprimindo um Vetor
Problema: Fazer um programa para ler um número inteiro N, depois ler N números double e armazená-los em um vetor. Em seguida, mostrar na tela todos os elementos do vetor.
Solução em Java:
package curso;
import java.util.Locale;
import java.util.Scanner;
public class LerVetor {
public static void main(String[] args) {
Locale.setDefault(Locale.US);
Scanner sc = new Scanner(System.in);
System.out.print("Quantos números você vai digitar? ");
int N = sc.nextInt();
// Instanciando o vetor com o tamanho N informado pelo usuário
double[] vet = new double[N];
// Laço para ler e armazenar cada número no vetor
for (int i = 0; i < N; i++) {
System.out.print("Digite um número: ");
vet[i] = sc.nextDouble();
}
// Laço para imprimir os elementos do vetor
System.out.println("\nNÚMEROS DIGITADOS:");
for (int i = 0; i < N; i++) {
System.out.printf("%.1f\n", vet[i]);
}
sc.close();
}
}
Exemplo de Execução:
Quantos números você vai digitar? 4
Digite um número: 10.5
Digite um número: 4.2
Digite um número: -7.1
Digite um número: 15.0
NÚMEROS DIGITADOS:
10.5
4.2
-7.1
15.0
📈 Exercício Completo: Análise de Alturas
Vamos resolver um problema mais elaborado que utiliza vetores paralelos (vários vetores cujos índices se correspondem).
Problema: Fazer um programa para ler nome, idade e altura de N pessoas. Depois, o programa deve mostrar a altura média das pessoas e a porcentagem de pessoas com menos de 16 anos, listando o nome delas.
Solução em Java:
package curso;
import java.util.Locale;
import java.util.Scanner;
public class AnaliseAlturas {
public static void main(String[] args) {
Locale.setDefault(Locale.US);
Scanner sc = new Scanner(System.in);
System.out.print("Quantas pessoas serão digitadas? ");
int N = sc.nextInt();
// Declarando os vetores paralelos
String[] nomes = new String[N];
int[] idades = new int[N];
double[] alturas = new double[N];
// Lendo os dados de cada pessoa
for (int i = 0; i < N; i++) {
System.out.println("Dados da " + (i + 1) + "ª pessoa:");
System.out.print("Nome: ");
sc.nextLine(); // Consome a quebra de linha pendente
nomes[i] = sc.nextLine();
System.out.print("Idade: ");
idades[i] = sc.nextInt();
System.out.print("Altura: ");
alturas[i] = sc.nextDouble();
}
// Processando os dados: calculando a soma das alturas e contando menores de 16
double somaAlturas = 0.0;
int contMenores = 0;
for (int i = 0; i < N; i++) {
somaAlturas += alturas[i];
if (idades[i] < 16) {
contMenores++;
}
}
// Calculando a média de altura
double alturaMedia = somaAlturas / N;
// Calculando o percentual de menores de 16 anos
// A fórmula é x = cont * 100 / N
double percentualMenores = ((double) contMenores * 100.0) / N;
// Apresentando os resultados
System.out.printf("\nAltura média: %.2f\n", alturaMedia);
System.out.printf("Pessoas com menos de 16 anos: %.1f%%\n", percentualMenores);
// Imprimindo o nome dos menores de 16
for (int i = 0; i < N; i++) {
if (idades[i] < 16) {
System.out.println(nomes[i]);
}
}
sc.close();
}
}
🛠️ Como Executar no VS Code e IntelliJ IDEA
Você pode compilar e executar todos os exemplos de código acima em qualquer uma das IDEs modernas.
No Visual Studio Code
- Instale o Pacote de Extensões para Java: Na aba de Extensões (
Ctrl+Shift+X), procure porExtension Pack for Javada Microsoft e instale-o. - Crie o Arquivo: Crie um novo arquivo com a extensão
.java(ex:LerVetor.java). - Cole o Código: Copie e cole um dos exemplos no arquivo.
- Execute: Um botão "Run" aparecerá acima do método
main. Clique nele para compilar e executar o código. A saída aparecerá no terminal integrado.
Na IntelliJ IDEA
- Crie um Novo Projeto: Vá em
File > New > Project. EscolhaJavae a versão do JDK. - Crie uma Nova Classe: Na janela de projeto, clique com o botão direito na pasta
src, vá emNew > Java Classe dê um nome à classe (ex:AnaliseAlturas). - Cole o Código: Copie e cole o código correspondente na classe criada.
- Execute: Clique com o botão direito do mouse em qualquer lugar dentro do editor de código e selecione Run 'NomeDaClasse.main()'. A saída aparecerá na aba "Run" na parte inferior da IDE.
🚀 ricardotecpro.github.io
🎛️ Matrizes (Arrays Bidimensionais) em Programação
Dando um passo além dos vetores (arrays de uma dimensão), as matrizes nos permitem trabalhar com dados estruturados em duas dimensões, como tabelas, planilhas ou tabuleiros.
🤔 O que são Matrizes?
[cite_start]Uma matriz é uma coleção de dados que pode ser entendida como um array bidimensional[cite: 27]. Ela possui um conjunto de características fundamentais:
- [cite_start]Indexada: Os elementos são acessados por meio de um par de índices: um para a linha e outro para a coluna[cite: 18]. Em Java, a sintaxe é
matriz[linha][coluna]. - [cite_start]Bidimensional: Organiza os dados em uma estrutura de duas dimensões, composta por linhas e colunas[cite: 21].
- [cite_start]Homogênea: Todos os dados armazenados na matriz devem ser do mesmo tipo (
int,double,String, etc.)[cite: 24]. - [cite_start]Tamanho Fixo: Uma vez que a matriz é criada (alocada na memória), seu tamanho (número de linhas e colunas) não pode ser alterado[cite: 26].
Visualmente, podemos imaginar uma matriz como uma grade:
🛠️ Trabalhando com Matrizes em Java
Vamos ver como declarar, instanciar e manipular matrizes na linguagem Java.
Declaração e Instanciação
Para criar uma matriz, você precisa declarar seu tipo e, em seguida, instanciá-la, definindo seu número de linhas e colunas.
// Sintaxe: tipo[][] nomeDaMatriz = new tipo[numeroDeLinhas][numeroDeColunas];
// Exemplo: Criando uma matriz de inteiros com 3 linhas e 4 colunas.
int[][] matriz = new int[3][4];
Isso aloca um espaço na memória para 12 números inteiros (3 linhas x 4 colunas).
Acessando Elementos
Para atribuir ou ler um valor, você utiliza os índices da linha e da coluna. Lembre-se que em Java, os índices sempre começam em zero.
// Atribuindo o valor 10 à segunda linha (índice 1), terceira coluna (índice 2)
matriz[1][2] = 10; [cite_start]// Equivalente ao A[1, 2] <- 10 do pseudocódigo [cite: 41]
// Lendo e imprimindo o valor
System.out.println(matriz[1][2]); // Saída: 10
✍️ Exemplo Prático: Lendo e Imprimindo uma Matriz
Vamos criar um programa que pergunta ao usuário as dimensões de uma matriz, lê cada um de seus elementos e, ao final, a imprime na tela de forma organizada.
Problema: Fazer um programa para ler dois números inteiros M e N e depois ler uma matriz de M linhas por N colunas contendo números inteiros. [cite_start]Em seguida, mostrar a matriz lida[cite: 66, 67].
Solução em Java:
package curso;
import java.util.Scanner;
public class LerMatriz {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Quantas linhas vai ter a matriz? ");
int M = sc.nextInt();
System.out.print("Quantas colunas vai ter a matriz? ");
int N = sc.nextInt();
// Instanciando a matriz com as dimensões informadas
int[][] mat = new int[M][N];
// Usando laços aninhados para ler os dados
System.out.println("Digite os elementos da matriz:");
for (int i = 0; i < M; i++) { // Laço para percorrer as linhas
for (int j = 0; j < N; j++) { // Laço para percorrer as colunas
System.out.printf("Elemento [%d,%d]: ", i, j);
mat[i][j] = sc.nextInt();
}
}
// Usando laços aninhados para imprimir a matriz
System.out.println("\nMATRIZ DIGITADA:");
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
System.out.print(mat[i][j] + " "); // Imprime o elemento e um espaço
}
System.out.println(); // Pula para a próxima linha ao final de cada linha da matriz
}
sc.close();
}
}
Exemplo de Execução:
Quantas linhas vai ter a matriz? 2
Quantas colunas vai ter a matriz? 3
Digite os elementos da matriz:
Elemento [0,0]: 5
Elemento [0,1]: 8
Elemento [0,2]: 10
Elemento [1,0]: -2
Elemento [1,1]: 9
Elemento [1,2]: 7
MATRIZ DIGITADA:
5 8 10
-2 9 7
🧠 Exercícios de Lógica com Matrizes
Vamos transformar alguns dos "testes de mesa" do material de estudo em programas Java funcionais para ver a lógica em ação.
Exercício 1: Populando com uma Regra
Problema: Crie um programa que preenche uma matriz 3x3 onde o valor de cada elemento é a soma de seus índices (linha + coluna).
Solução em Java:
package curso;
public class PopularMatrizRegra {
public static void main(String[] args) {
int N = 3;
int[][] matriz = new int[N][N];
// Populando a matriz com a regra mat[i][j] = i + j
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
matriz[i][j] = i + j; // Regra de população
}
}
// Imprimindo a matriz resultante
System.out.println("Matriz gerada:");
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
System.out.print(matriz[i][j] + " ");
}
System.out.println();
}
}
}
Saída Esperada:
Exercício 2: Soma dos Elementos de Cada Linha
Problema: Faça um programa que crie uma matriz 3x4, popule-a com valores, e em seguida, crie um vetor onde cada posição armazena a soma dos elementos da linha correspondente da matriz.
Solução em Java:
package curso;
public class SomaLinhasMatriz {
public static void main(String[] args) {
int M = 3; // Linhas
int N = 4; // Colunas
int[][] matriz = {
{5, 10, 2, 8},
{4, 3, 9, 1},
{7, 6, 5, 2}
};
// Vetor para armazenar a soma de cada linha
int[] vetorSomas = new int[M];
// Calculando a soma de cada linha
for (int i = 0; i < M; i++) {
int soma = 0;
for (int j = 0; j < N; j++) {
soma += matriz[i][j];
}
vetorSomas[i] = soma;
}
// Imprimindo o vetor com as somas
System.out.println("Soma de cada linha:");
for (int i = 0; i < M; i++) {
System.out.printf("Linha %d: %d\n", i, vetorSomas[i]);
}
}
}
Saída Esperada:
🛠️ Como Executar no VS Code e IntelliJ IDEA
Você pode compilar e executar todos os exemplos de código acima em qualquer uma das IDEs modernas.
No Visual Studio Code
- Instale o Pacote de Extensões para Java: Na aba de Extensões (
Ctrl+Shift+X), procure porExtension Pack for Javada Microsoft e instale-o. - Crie o Arquivo: Crie um novo arquivo com a extensão
.java(ex:LerMatriz.java). - Cole o Código: Copie e cole um dos exemplos no arquivo.
- Execute: Um botão "Run" aparecerá acima do método
main. Clique nele para compilar e executar o código. A saída aparecerá no terminal integrado.
Na IntelliJ IDEA
- Crie um Novo Projeto: Vá em
File > New > Project. EscolhaJavae a versão do JDK. - Crie uma Nova Classe: Na janela de projeto, clique com o botão direito na pasta
src, vá emNew > Java Classe dê um nome à classe (ex:SomaLinhasMatriz). - Cole o Código: Copie e cole o código correspondente na classe criada.
- Execute: Clique com o botão direito do mouse em qualquer lugar dentro do editor de código e selecione Run 'NomeDaClasse.main()'. A saída aparecerá na aba "Run" na parte inferior da IDE.
🚀 ricardotecpro.github.io
📦 Funções (Métodos) em Programação
Funções, que em Java e em outras linguagens orientadas a objetos são mais comumente chamadas de métodos, são um dos pilares da programação estruturada. Elas nos permitem organizar e reutilizar código, tornando nossos programas mais modulares, legíveis e fáceis de manter.
🤔 O que são Funções (ou Métodos)?
De maneira informal, uma função (ou método) é uma unidade de código autônoma que realiza uma tarefa específica. Ela também pode ser chamada de subprograma ou sub-rotina. Suas principais características são:
- Pode receber parâmetros (ou argumentos) de entrada.
- Pode executar uma lógica interna.
- Pode retornar um valor de saída.
Qual a importância de usar funções?
Utilizar funções traz enormes benefícios para o desenvolvimento de software:
- Dividir para conquistar: Permite quebrar um problema complexo em problemas menores e mais gerenciáveis.
- Organização e Legibilidade: O código fica mais limpo e mais fácil de entender.
- Reaproveitamento de código: Uma função escrita uma vez pode ser chamada (usada) várias vezes em diferentes partes do programa.
- Delegação: Facilita a atribuição de responsabilidades em projetos de equipe.
Dissecando um Método em Java
Vamos analisar a estrutura de um método em Java, traduzindo o exemplo media do material de estudo.
// (1) (2) (3) (4)
public static double calcularMedia(double a, double b) {
// (5) Corpo do método
double soma = a + b; // Variável local do método
// (6) Retorno do método
return soma / 2.0;
}
- Modificadores de Acesso e
static:publicsignifica que o método pode ser chamado de qualquer lugar.staticindica que o método pertence à classe, e não a um objeto específico (essencial para chamá-lo diretamente domain). - Tipo de Retorno:
doubleindica o tipo de dado que o método irá retornar ao final de sua execução. - Nome do Método:
calcularMediaé o identificador que usamos para chamar o método. - Parâmetros de Entrada:
(double a, double b)é a lista de parâmetros que o método espera receber. - Corpo do Método: O bloco de código entre chaves
{}onde a lógica é executada. - Comando
return: Envia o resultado do cálculo de volta para quem chamou o método.
Chamando um Método
Para usar um método, você o "chama" pelo nome, passando os valores esperados para os parâmetros.
public static void main(String[] args) {
// Chamando o método e armazenando o resultado
double mediaFinal = calcularMedia(8.0, 7.5);
System.out.println("A média é: " + mediaFinal); // Saída: A média é: 7.75
}
🔐 Escopo de Variáveis
O escopo de uma variável define onde ela é "visível" e pode ser utilizada.
Em Java, as variáveis declaradas dentro de um método, incluindo seus parâmetros, são locais. Isso significa que elas só existem e só podem ser acessadas dentro daquele método.
- Uma função não "enxerga" as variáveis locais de outra função.
- Se duas funções diferentes tiverem variáveis com o mesmo nome, elas são completamente independentes uma da outra.
Exemplo:
public static void funcaoF() {
int x = 10; // 'x' só existe aqui dentro
System.out.println("Dentro da funcaoF, x = " + x);
}
public static void funcaoG() {
int x = 99; // Este é outro 'x', totalmente diferente do anterior
System.out.println("Dentro da funcaoG, x = " + x);
// System.out.println(funcaoF.x); // ERRO! Não é possível acessar o 'x' da funcaoF
}
Boas Práticas: Para que uma função seja previsível e reutilizável, ela deve, idealmente, ser uma função pura. Isso significa que seu resultado deve depender apenas de seus parâmetros de entrada, sem acessar ou modificar variáveis de fora de seu escopo (evitando "efeitos colaterais").
📝 Documentando Métodos com Javadoc
Documentar seu código é crucial. Em Java, o padrão para isso é o Javadoc. A documentação é feita em um bloco de comentário especial (/** ... */) logo acima da assinatura do método.
- Assinatura: A primeira linha da definição do método.
- Descrição dos Parâmetros: O que cada parâmetro de entrada representa (usando a tag
@param). - Efeito da Função: O que a função faz e o que ela retorna (usando a tag
@return).
Exemplo com a fórmula de Heron:
/**
* Calcula a área de um triângulo usando a fórmula de Heron.
*
* @param a Primeiro lado do triângulo
* @param b Segundo lado do triângulo
* @param c Terceiro lado do triângulo
* @return A área calculada do triângulo
*/
public static double areaTriangulo(double a, double b, double c) {
double p = (a + b + c) / 2.0;
return Math.sqrt(p * (p - a) * (p - b) * (p - c));
}
📢 Métodos que Não Retornam Valor (void)
Às vezes, uma função precisa executar uma ação (como imprimir algo na tela) em vez de calcular e retornar um valor. Esses métodos são chamados de procedimentos em algumas linguagens.
Em Java, eles são declarados com o tipo de retorno void.
Exemplo: Gerar um Relatório
Problema: Ler os dados de um contrato e mostrar um relatório formatado na tela.
Solução em Java com void:
import java.util.Locale;
import java.util.Scanner;
public class RelatorioFinanceiro {
/**
* Exibe um relatório de financiamento formatado no console.
* @param nome O nome do cliente
* @param total O valor total do financiamento
* @param entrada O valor da entrada
*/
public static void mostrarRelatorio(String nome, double total, double entrada) {
double restante = total - entrada;
System.out.println("\n--- RELATÓRIO ---");
System.out.println("NOME: " + nome);
System.out.printf("VALOR TOTAL: R$ %.2f\n", total);
System.out.printf("VALOR DE ENTRADA: R$ %.2f\n", entrada);
System.out.printf("VALOR PARCELADO: R$ %.2f\n", restante);
System.out.println("-----------------");
}
public static void main(String[] args) {
Locale.setDefault(Locale.US);
Scanner sc = new Scanner(System.in);
System.out.print("Nome do cliente: ");
String nomeCliente = sc.nextLine();
System.out.print("Valor total financiado: ");
double valorTotal = sc.nextDouble();
System.out.print("Valor de entrada: ");
double valorEntrada = sc.nextDouble();
// A chamada de um método void é uma instrução "solta"
mostrarRelatorio(nomeCliente, valorTotal, valorEntrada);
sc.close();
}
}
✍️ Exercícios Práticos Resolvidos
Exercício 1: Área de Triângulos
Problema: Ler as medidas dos lados de dois triângulos, X e Y. Em seguida, mostrar o valor da área de cada um, reutilizando a lógica de cálculo.
Solução em Java:
// O método areaTriangulo() já foi definido e documentado acima.
public static void main(String[] args) {
Locale.setDefault(Locale.US);
// Medidas do triângulo X
double areaX = areaTriangulo(3.00, 4.00, 5.00);
// Medidas do triângulo Y
double areaY = areaTriangulo(7.50, 4.50, 4.02);
System.out.printf("Área de X = %.4f\n", areaX);
System.out.printf("Área de Y = %.4f\n", areaY);
}
Saída Esperada:
Exercício 2: Funções que Chamam Funções
Problema: Fazer um programa para ler cinco números inteiros e mostrar o menor dentre eles, reaproveitando a lógica ao máximo.
Solução em Java:
/**
* Encontra o menor valor entre três números inteiros.
* @return O menor dos três números
*/
public static int menorDeTres(int x, int y, int z) {
if (x < y && x < z) {
return x;
} else if (y < z) {
return y;
} else {
return z;
}
}
/**
* Encontra o menor valor entre cinco números inteiros,
* reutilizando a função menorDeTres.
* @return O menor dos cinco números
*/
public static int menorDeCinco(int n1, int n2, int n3, int n4, int n5) {
// Encontra o menor dos três primeiros
int aux = menorDeTres(n1, n2, n3);
// Compara o resultado anterior com os dois últimos números
return menorDeTres(aux, n4, n5);
}
public static void main(String[] args) {
int menor = menorDeCinco(9, 5, 3, 12, 7);
System.out.println("Menor = " + menor); // Saída: Menor = 3
}
🚀 ricardotecpro.github.io
Introdução às Linguagens
Linguagem C 📖
Este guia é um material de apoio completo para quem está começando na linguagem C, especialmente para estudantes que já possuem uma base em lógica de programação.
🛠️ Instalação e Configuração do Ambiente (VS Code)
Para programar em C, você precisará de duas ferramentas principais: um compilador e um Editor de Código/IDE.
- Compilador: É o programa que traduz seu código C (legível por humanos) para código de máquina (executável pelo computador). Usaremos o GCC, que faz parte do pacote MinGW para Windows.
- IDE (Ambiente de Desenvolvimento Integrado): É um editor de texto com superpoderes para programadores. Usaremos o Visual Studio Code (VS Code), que é moderno, gratuito e altamente customizável.
Passos para Configuração:
-
Instale o Compilador (MinGW-w64):
- Acesse o site oficial do MinGW-w64 e faça o download do instalador.
- Durante a instalação, na tela de "Settings", certifique-se de que a arquitetura (
Architecture) está definida comox86_64e clique emNext. - Adicione o MinGW ao Path do Windows: É crucial que o sistema operacional saiba onde encontrar o compilador. Adicione o caminho da pasta
bindo MinGW (ex:C:\Program Files\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin) à variável de ambientePath.
-
Instale o VS Code:
- Baixe e instale o Visual Studio Code.
-
Instale a Extensão C/C++ no VS Code:
- Abra o VS Code, vá para a aba de
Extensions(ícone de blocos no menu lateral). - Procure por "C/C++" da Microsoft e clique em
Install.
- Abra o VS Code, vá para a aba de
🚀 Seu Primeiro Programa em C
Vamos criar um programa clássico que exibe uma mensagem na tela.
Análise do Código:
#include <stdio.h>: Importa a biblioteca padrão de entrada e saída de dados (Standard Input/Output), que nos dá acesso a funções comoprintf.int main(): É a função principal, o ponto de partida de todo programa em C.printf("Ola, Universo C!\n");: A funçãoprintfé usada para "imprimir" texto no console. O\né um caractere especial que significa "nova linha".return 0;: Indica que o programa foi executado com sucesso e terminou sem erros.
📊 Tipos de Dados e Variáveis
Variáveis são espaços na memória que reservamos para armazenar dados. Em C, toda variável precisa ter um tipo definido.
| Significado | Tipo em C | Exemplo de Declaração | Observações |
|---|---|---|---|
| Número Inteiro | int |
int idade; |
Armazena números inteiros. O intervalo pode ser estendido com long int ou long long int. |
| Número com Ponto Flutuante | double |
double salario; |
Armazena números reais com alta precisão. Para precisão menor (e menos uso de memória), pode-se usar float. |
| Um Único Caractere | char |
char genero; |
Armazena um único caractere, que deve ser envolvido por aspas simples. Ex: 'F'. |
| Texto (String) | char[] |
char nome[50]; |
Em C, um texto é um vetor (array) de caracteres. O valor deve ser envolvido por aspas duplas. Ex: "Ana Souza". |
| Valor Lógico (Booleano) | int (tradicional) ou bool |
int temFilhos; |
C tradicionalmente usa int: 0 representa falso e qualquer outro número representa verdadeiro. |
Nota: Em C moderno (padrão C99 em diante), você pode incluir a biblioteca <stdbool.h> para usar os tipos bool, true e false, o que torna o código mais legível.
📝 Declaração e Atribuição de Variáveis
Você pode declarar uma variável e atribuir um valor a ela na mesma linha ou em momentos diferentes.
#include <stdio.h>
#include <string.h> // Necessário para a função strcpy
int main() {
// Declaração de variáveis
int idade;
double salario, altura;
char genero;
char nome[50];
// Atribuição de valores
idade = 25;
salario = 6200.75;
altura = 1.70;
genero = 'F';
strcpy(nome, "Ana Souza"); // Função para copiar um texto para uma variável string
// Saída de dados
printf("IDADE = %d\n", idade);
printf("SALARIO = %.2f\n", salario); // %.2f formata para 2 casas decimais
printf("ALTURA = %.2f\n", altura);
printf("GENERO = %c\n", genero);
printf("NOME = %s\n", nome);
return 0;
}
Saída Esperada:
Importante:
- A atribuição de texto a um vetor
charapós sua declaração deve ser feita com a funçãostrcpy(string copy). - Você também pode inicializar a variável na mesma linha da declaração, o que é mais comum:
int idade = 25;ouchar nome[50] = "Ana Souza";.
🔢 Operadores
Aritméticos
| Operador | Significado |
|---|---|
+ |
Adição |
- |
Subtração |
* |
Multiplicação |
/ |
Divisão |
% |
Resto da divisão (módulo) |
Comparativos
| Operador | Significado |
|---|---|
< |
Menor que |
> |
Maior que |
<= |
Menor ou igual a |
>= |
Maior ou igual a |
== |
Igual a |
!= |
Diferente de |
Lógicos
| Operador | Significado |
|---|---|
&& |
E (AND) |
|| |
OU (OR) |
! |
NÃO (NOT) |
📤 Saída de Dados (printf)
A função printf usa "placeholders" (marcadores de posição) para exibir o conteúdo de variáveis.
| Tipo | Placeholder |
|---|---|
int |
%d ou %i |
long int |
%li |
long long int |
%lli |
float |
%f |
double |
%lf (com scanf), mas %f é comum para printf |
char (um caractere) |
%c |
char[] (texto) |
%s |
Exemplo Prático:
#include <stdio.h>
#include <string.h>
int main() {
int idade = 25;
double salario = 6200.75;
char nome[50] = "Ana Souza";
char genero = 'F';
// Imprimindo uma frase formatada
printf("A funcionaria %s, do sexo %c, tem %d anos e recebe R$ %.2f.\n", nome, genero, idade, salario);
return 0;
}
Saída Esperada:
🔄 Processamento de Dados e Casting
O casting é uma conversão explícita de um tipo de dado para outro. É útil em situações como a divisão de inteiros, onde o resultado pode ser truncado.
Exemplo 1: Divisão de Inteiros
#include <stdio.h>
int main() {
int a = 10;
int b = 3;
int resultado;
resultado = a / b;
printf("Resultado: %d\n", resultado); // Saída será 3, a parte decimal é perdida
return 0;
}
Saída Esperada:
Exemplo 2: Casting para Divisão Correta
Para obter um resultado com casas decimais, precisamos converter um dos operandos para double ou float.
#include <stdio.h>
int main() {
int a = 10;
int b = 3;
double resultado;
resultado = (double) a / b; // Casting de 'a' para double antes da divisão
printf("Resultado: %.2f\n", resultado); // Saída será 3.33
return 0;
}
Saída Esperada:
📥 Entrada de Dados (scanf)
Para ler dados digitados pelo usuário, usamos a função scanf. Ela utiliza os mesmos placeholders que o printf.
O Desafio do Buffer de Entrada
Um problema comum em C é o "lixo" deixado no buffer de entrada (uma área de memória temporária). Quando você lê um número com scanf("%d", &idade);, o número é lido, mas a tecla Enter (\n) que você pressionou continua no buffer. Se a próxima leitura for de um caractere ou de um texto, ela pode capturar esse \n indesejado.
Solução: Funções de Limpeza Para evitar problemas, podemos criar uma função para limpar o buffer antes de ler um texto ou um caractere que venha depois de uma leitura de número.
#include <stdio.h>
#include <string.h>
// Função para limpar o buffer de entrada
void limpar_entrada() {
char c;
while ((c = getchar()) != '\n' && c != EOF) {}
}
// Função para ler texto de forma segura
void ler_texto(char *buffer, int length) {
fgets(buffer, length, stdin);
strtok(buffer, "\n"); // Remove a quebra de linha que o fgets captura
}
int main() {
int idade;
double salario;
char nome[50];
char genero;
printf("Digite seu nome completo: ");
ler_texto(nome, 50);
printf("Digite sua idade: ");
scanf("%d", &idade);
// Limpa o buffer antes de ler o próximo caractere
limpar_entrada();
printf("Digite seu genero (M/F): ");
scanf("%c", &genero);
printf("Digite seu salario: ");
scanf("%lf", &salario);
printf("\n--- DADOS CADASTRADOS ---\n");
printf("Nome: %s\n", nome);
printf("Idade: %d\n", idade);
printf("Genero: %c\n", genero);
printf("Salario: %.2f\n", salario);
return 0;
}
🔀 Estrutura Condicional (if-else)
Permite que o programa tome decisões com base em condições.
#include <stdio.h>
int main() {
int hora;
printf("Digite uma hora do dia (0-23): ");
scanf("%d", &hora);
if (hora < 12) {
printf("Bom dia!\n");
}
else if (hora < 18) {
printf("Boa tarde!\n");
}
else {
printf("Boa noite!\n");
}
return 0;
}
🔁 Estruturas de Repetição
while (Enquanto)
Executa um bloco de código enquanto uma condição for verdadeira. A condição é testada antes da primeira execução.
#include <stdio.h>
int main() {
int numero, soma = 0;
printf("Digite um numero (0 para sair): ");
scanf("%d", &numero);
while (numero != 0) {
soma = soma + numero;
printf("Digite outro numero (0 para sair): ");
scanf("%d", &numero);
}
printf("SOMA FINAL = %d\n", soma);
return 0;
}
for (Para)
Ideal para repetir um bloco de código um número definido de vezes.
#include <stdio.h>
int main() {
int N, i, valor, soma;
printf("Quantos numeros serao digitados? ");
scanf("%d", &N);
soma = 0;
for (i = 0; i < N; i++) {
printf("Digite o valor #%d: ", i + 1);
scanf("%d", &valor);
soma += valor; // Forma abreviada de soma = soma + valor
}
printf("SOMA FINAL = %d\n", soma);
return 0;
}
do-while (Faça-Enquanto)
Similar ao while, mas garante que o bloco de código seja executado pelo menos uma vez, pois a condição é testada no final.
#include <stdio.h>
void limpar_entrada() {
char c;
while ((c = getchar()) != '\n' && c != EOF) {}
}
int main() {
double C, F;
char resposta;
do {
printf("Digite a temperatura em Celsius: ");
scanf("%lf", &C);
F = C * 9.0 / 5.0 + 32.0;
printf("Equivalente em Fahrenheit: %.1f\n", F);
printf("Deseja repetir (s/n)? ");
limpar_entrada();
scanf("%c", &resposta);
} while (resposta == 's');
return 0;
}
📏 Vetores (Arrays)
Vetores são coleções de dados do mesmo tipo, acessados por um índice. Em C, o primeiro índice é sempre 0.
#include <stdio.h>
int main() {
int N, i;
printf("Quantos numeros voce vai digitar? ");
scanf("%d", &N);
double numeros[N]; // Declara um vetor de 'N' posições
for (i = 0; i < N; i++) {
printf("Digite o numero %d: ", i + 1);
scanf("%lf", &numeros[i]);
}
printf("\nNUMEROS DIGITADOS:\n");
for (i = 0; i < N; i++) {
printf("%.1f\n", numeros[i]);
}
return 0;
}
▦ Matrizes (Arrays 2D)
Matrizes são vetores de vetores, usados para representar tabelas ou grades.
#include <stdio.h>
int main() {
int M, N, i, j;
printf("Quantas linhas tera a matriz? ");
scanf("%d", &M);
printf("Quantas colunas tera a matriz? ");
scanf("%d", &N);
int matriz[M][N];
for (i = 0; i < M; i++) {
for (j = 0; j < N; j++) {
printf("Elemento [%d,%d]: ", i, j);
scanf("%d", &matriz[i][j]);
}
}
printf("\nMATRIZ DIGITADA:\n");
for (i = 0; i < M; i++) {
for (j = 0; j < N; j++) {
printf("%d ", matriz[i][j]);
}
printf("\n"); // Pula para a próxima linha
}
return 0;
}
🐞 Depuração (Debugging) no VS Code
Debugging é o processo de encontrar e corrigir erros no seu código. O VS Code oferece uma ferramenta de depuração poderosa.
Passos Básicos:
- Marcar um Breakpoint: Clique na margem esquerda do editor, ao lado do número da linha. Uma bola vermelha aparecerá. O breakpoint é um ponto de parada onde a execução do programa será pausada.
- Iniciar a Depuração: Pressione
F5ou vá para a abaRun and Debuge clique no botão verdeStart Debugging. - Analisar Variáveis: Com a execução pausada, a janela
VARIABLESno painel esquerdo mostrará o valor atual de todas as variáveis locais. - Controlar a Execução:
- Step Over (
F10): Executa a linha atual e para na próxima. - Step Into (
F11): Se a linha atual for uma chamada de função, entra na função para depurá-la. - Continue (
F5): Continua a execução normal até o próximo breakpoint ou o fim do programa. - Stop (
Shift+F5): Para a sessão de depuração.
- Step Over (
ricardotecpro.github.io
Linguagem C++ 💻
Bem-vindo ao guia de C++, uma evolução da linguagem C com recursos poderosos como orientação a objetos, strings nativas e um sistema de entrada e saída mais robusto. Este material é ideal para quem já tem noções de lógica e busca dominar os fundamentos do C++.
🛠️ Instalação e Configuração do Ambiente (VS Code)
Assim como em C, para programar em C++ você precisa de um compilador e de um IDE. O compilador para C++ que usaremos é o g++, que também faz parte do pacote MinGW.
O processo de instalação é o mesmo do guia de C:
- Instale o Compilador (MinGW-w64): Siga as instruções para instalar o MinGW e adicionar sua pasta
binà variável de ambientePathdo Windows. Isso dará ao sistema acesso tanto aogcc(para C) quanto aog++(para C++). - Instale o VS Code: Baixe e instale o Visual Studio Code.
- Instale a Extensão C/C++: No VS Code, instale a extensão "C/C++" da Microsoft para habilitar o suporte completo à linguagem.
🚀 Seu Primeiro Programa em C++
Vamos criar o programa "Olá, Mundo!" na versão C++.
#include <iostream>
using namespace std;
int main() {
cout << "Ola, Universo C++!" << endl;
return 0;
}
Saída Esperada:
Análise do Código:
#include <iostream>: Importa a biblioteca de stream (fluxo) de entrada e saída, essencial para usarcoutecin.using namespace std;: Indica que usaremos elementos do namespace (espaço de nomes)std(standard/padrão). Isso nos permite escrevercoutem vez destd::cout.int main(): A função principal onde a execução do programa começa.cout << "..." << endl;:couté o objeto de saída padrão (o console). O operador<<"insere" dados no fluxo de saída.endlinsere uma nova linha e limpa o buffer.return 0;: Informa ao sistema operacional que o programa terminou com sucesso.
📊 Tipos de Dados e Variáveis
C++ herda os tipos de dados de C, mas adiciona tipos nativos que facilitam muito a programação, como string e bool.
| Significado | Tipo em C++ | Exemplo de Declaração | Observações |
|---|---|---|---|
| Número Inteiro | int |
int quantidade; |
Armazena números inteiros. Use long long para números muito grandes. |
| Número com Ponto Flutuante | double |
double preco; |
Armazena números reais com alta precisão. float pode ser usado para precisão simples. |
| Um Único Caractere | char |
char categoria; |
Armazena um caractere entre aspas simples. Ex: 'A'. |
| Texto (String) | string |
string nomeProduto; |
Um tipo nativo poderoso e flexível para textos. Requer a biblioteca <string> e usa aspas duplas. |
| Valor Lógico (Booleano) | bool |
bool emEstoque; |
Armazena os valores true (verdadeiro) ou false (falso). |
📝 Declaração e Atribuição de Variáveis
A declaração e atribuição em C++ são diretas e intuitivas, especialmente com o tipo string.
#include <iostream>
#include <string>
#include <iomanip> // Para formatar a saída de dados
using namespace std;
int main() {
// Declaração e inicialização de variáveis
int idade = 35;
double salario = 7500.90;
double altura = 1.82;
char genero = 'M';
string nome = "Carlos Pereira"; // Atribuição direta e simples
// Configura a saída para exibir 2 casas decimais em números double
cout << fixed << setprecision(2);
// Saída de dados
cout << "NOME = " << nome << endl;
cout << "IDADE = " << idade << endl;
cout << "GENERO = " << genero << endl;
cout << "ALTURA = " << altura << endl;
cout << "SALARIO = R$ " << salario << endl;
return 0;
}
Saída Esperada:
🔢 Operadores
Os operadores em C++ são, em sua maioria, idênticos aos da linguagem C.
Aritméticos
| Operador | Significado |
|---|---|
+ |
Adição |
- |
Subtração |
* |
Multiplicação |
/ |
Divisão |
% |
Resto da divisão (módulo) |
Comparativos
| Operador | Significado |
|---|---|
< |
Menor que |
> |
Maior que |
<= |
Menor ou igual a |
>= |
Maior ou igual a |
== |
Igual a |
!= |
Diferente de |
Lógicos
| Operador | Significado |
|---|---|
&& |
E (AND) |
|| |
OU (OR) |
! |
NÃO (NOT) |
📤 Saída de Dados com cout
O cout é o principal meio de exibir informações no console em C++. Para formatar números, usamos manipuladores da biblioteca <iomanip>.
cout << fixed << setprecision(N);: Define que a saída de números de ponto flutuante terá um número fixo deNcasas decimais.
Nota sobre #include <bits/stdc++.h>:
Você pode encontrar este comando em alguns códigos. Ele é um atalho (não padrão do C++) que inclui todas as bibliotecas padrão de uma vez. Embora seja prático para competições de programação, não é recomendado em projetos profissionais, pois aumenta o tempo de compilação e pode não ser compatível com todos os compiladores.
🔄 Processamento de Dados e Casting
O casting (conversão de tipo) em C++ funciona de forma similar ao C e é crucial para operações matemáticas precisas.
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
int a = 11;
int b = 4;
double resultado;
// A divisão de dois inteiros resulta em um inteiro (a parte decimal é truncada)
cout << "Divisao de inteiros: " << a / b << endl; // Saída: 2
// Fazendo o casting de 'a' para double para obter um resultado preciso
resultado = (double) a / b;
cout << fixed << setprecision(2);
cout << "Divisao com casting: " << resultado << endl; // Saída: 2.75
return 0;
}
📥 Entrada de Dados com cin
Para receber dados do usuário, usamos o objeto cin com o operador de extração >>.
Lendo Textos com Espaços (getline)
O cin >> lê a entrada até encontrar um espaço em branco. Para ler uma linha inteira de texto (com espaços), usamos a função getline(cin, variavel_string);.
Limpando o Buffer de Entrada
Assim como em C, ler um número com cin >> deixa uma quebra de linha (\n) no buffer. Isso pode atrapalhar uma chamada subsequente a getline. Para resolver isso, limpamos o buffer.
cin.ignore(INT_MAX, '\n');: Ignora todos os caracteres no buffer até encontrar e descartar a próxima quebra de linha.
#include <iostream>
#include <string>
#include <iomanip>
#include <climits> // Para usar INT_MAX
using namespace std;
int main() {
int idade;
double salario;
string nome;
cout << "Digite sua idade: ";
cin >> idade;
cout << "Digite seu nome completo: ";
cin.ignore(INT_MAX, '\n'); // Limpeza de buffer obrigatória aqui!
getline(cin, nome);
cout << "Digite seu salario: ";
cin >> salario;
cout << fixed << setprecision(2);
cout << "\n--- DADOS DIGITADOS ---\n";
cout << "Nome: " << nome << endl;
cout << "Idade: " << idade << " anos" << endl;
cout << "Salario: R$ " << salario << endl;
return 0;
}
🔀 Estrutura Condicional (if-else)
Permite executar blocos de código diferentes com base em uma condição.
#include <iostream>
using namespace std;
int main() {
int hora;
cout << "Digite uma hora do dia (0-23): ";
cin >> hora;
if (hora < 12) {
cout << "Bom dia!" << endl;
}
else if (hora < 18) {
cout << "Boa tarde!" << endl;
}
else {
cout << "Boa noite!" << endl;
}
return 0;
}
🔁 Estruturas de Repetição
while (Enquanto)
Executa um bloco de código repetidamente enquanto uma condição for verdadeira. A condição é verificada antes de cada iteração.
#include <iostream>
using namespace std;
int main() {
int numero, soma = 0;
cout << "Digite um numero (0 para parar): ";
cin >> numero;
while (numero != 0) {
soma += numero;
cout << "Digite outro numero (0 para parar): ";
cin >> numero;
}
cout << "SOMA FINAL = " << soma << endl;
return 0;
}
for (Para)
É a estrutura ideal para laços com um número conhecido de repetições.
Sintaxe: for (inicialização; condição; incremento) { ... }
#include <iostream>
using namespace std;
int main() {
int N, valor, soma;
cout << "Quantos numeros voce quer somar? ";
cin >> N;
soma = 0;
for (int i = 0; i < N; i++) {
cout << "Digite o valor #" << i + 1 << ": ";
cin >> valor;
soma += valor;
}
cout << "SOMA = " << soma << endl;
return 0;
}
do-while (Faça-Enquanto)
Garante que o bloco de código seja executado pelo menos uma vez, pois a condição é verificada ao final da iteração.
#include <iostream>
using namespace std;
int main() {
double C, F;
char resposta;
do {
cout << "Digite a temperatura em Celsius: ";
cin >> C;
F = 9.0 * C / 5.0 + 32.0;
cout << "Equivalente em Fahrenheit: " << F << endl;
cout << "Deseja repetir (s/n)? ";
cin >> resposta;
} while (resposta == 's');
return 0;
}
📏 Vetores e Matrizes
Vetores (Arrays C-style)
Vetores são coleções de tamanho fixo de elementos do mesmo tipo.
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
int N;
cout << "Quantos numeros voce vai digitar? ";
cin >> N;
double vet[N]; // Vetor C-style de tamanho N
for (int i = 0; i < N; i++) {
cout << "Digite um numero: ";
cin >> vet[i];
}
cout << fixed << setprecision(1);
cout << "\nNUMEROS DIGITADOS:\n";
for (int i = 0; i < N; i++) {
cout << vet[i] << endl;
}
return 0;
}
Nota Moderna: Em C++ moderno, prefira usar std::vector (da biblioteca <vector>), que é um contêiner dinâmico e mais seguro.
Matrizes (Arrays 2D C-style)
Matrizes são estruturas bidimensionais, basicamente um vetor de vetores.
#include <iostream>
using namespace std;
int main() {
int M, N;
cout << "Quantas linhas tera a matriz? ";
cin >> M;
cout << "Quantas colunas tera a matriz? ";
cin >> N;
int mat[M][N];
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
cout << "Elemento [" << i << "," << j << "]: ";
cin >> mat[i][j];
}
}
cout << "\nMATRIZ DIGITADA:\n";
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
cout << mat[i][j] << " ";
}
cout << endl;
}
return 0;
}
Nota Moderna: Para matrizes dinâmicas em C++, a abordagem recomendada é std::vector<std::vector<int>>.
🐞 Depuração (Debugging) no VS Code
O processo de depuração em C++ no VS Code é idêntico ao de C.
- Marcar Breakpoints: Clique na margem à esquerda do número da linha para criar um ponto de parada.
- Iniciar Depuração: Pressione
F5para iniciar. - Controlar Execução: Use
F10(Step Over) para executar linha por linha eF5para continuar até o próximo breakpoint. - Analisar Variáveis: Inspecione os valores das variáveis na janela
VARIABLESdo painel de depuração.
ricardotecpro.github.io
Linguagem Java ☕
Bem-vindo ao guia da linguagem Java, uma das linguagens de programação mais populares e versáteis do mundo. Famosa por sua filosofia "escreva uma vez, rode em qualquer lugar" (write once, run anywhere), o Java é fundamental para o desenvolvimento de aplicações web, mobile (Android), e sistemas de grande escala.
🛠️ Instalação e Configuração do Ambiente
Para desenvolver em Java, o primeiro passo é instalar o JDK (Java Development Kit), que é um pacote de software contendo o compilador e outras ferramentas essenciais.
-
Instale o Java JDK:
- Faça o download do JDK (versão LTS, como 11, 17 ou 21, é recomendada) a partir do site oficial da Oracle ou de uma distribuição como o OpenJDK.
- Siga o instalador.
- Configure as Variáveis de Ambiente:
- Crie uma nova variável de ambiente
JAVA_HOMEapontando para a pasta de instalação do JDK (ex:C:\Program Files\Java\jdk-17.0.2). - Adicione o caminho da pasta
bindo JDK à variávelPathdo sistema (ex:%JAVA_HOME%\bin).
- Crie uma nova variável de ambiente
- Para verificar a instalação, abra um terminal e execute o comando
java -version.
-
Escolha uma IDE (Ambiente de Desenvolvimento Integrado): Enquanto o material original foca no Eclipse, as IDEs mais utilizadas atualmente para desenvolvimento Java são o VS Code e o IntelliJ IDEA.
Opção 1: VS Code
- Instale o Visual Studio Code.
- Na aba de extensões, instale o pacote "Extension Pack for Java" da Microsoft. Ele inclui tudo o que é necessário para compilar, executar e depurar código Java.
Opção 2: IntelliJ IDEA
- Baixe a versão Community (gratuita) do IntelliJ IDEA.
- O IntelliJ IDEA é altamente especializado para Java e oferece uma experiência de desenvolvimento muito produtiva, com ferramentas de análise de código e refatoração de ponta.
🚀 Seu Primeiro Programa em Java
Todo programa em Java é contido dentro de uma classe. A execução sempre começa no método main.
// É uma boa prática definir um pacote para organizar suas classes.
package curso;
// Declaração da classe principal.
public class Programa {
// Método principal, ponto de entrada do programa.
public static void main(String[] args) {
// Comando para imprimir uma linha no console.
System.out.println("Ola, Universo Java!");
}
}
📊 Tipos de Dados e Variáveis
Java possui tipos de dados primitivos para armazenar valores simples e tipos por referência (classes) para objetos complexos.
| Significado | Tipo em Java | Valor Padrão | Observação |
|---|---|---|---|
| Número Inteiro | int |
0 | O tipo padrão para inteiros. Use long para valores muito grandes. |
| Número de Ponto Flutuante | double |
0.0 | O tipo padrão para números reais. float oferece precisão simples. |
| Um Único Caractere | char |
'\u0000' |
Armazena um caractere Unicode, sempre entre aspas simples (ex: 'F'). |
| Texto | String |
null |
String é uma classe, não um tipo primitivo, e por isso começa com 'S' maiúsculo. Textos são declarados entre aspas duplas (ex: "Beatriz Costa"). |
| Valor Lógico | boolean |
false |
Aceita apenas os valores true ou false. |
📝 Declaração e Atribuição de Variáveis
A declaração de variáveis em Java exige a especificação de um tipo e um nome. A atribuição pode ser feita na mesma linha ou posteriormente.
package curso;
import java.util.Locale; // Importa a classe Locale para formatação.
public class Programa {
public static void main(String[] args) {
// Define o Locale para US para usar o ponto como separador decimal.
Locale.setDefault(Locale.US);
// Declaração e inicialização de variáveis.
int idade = 28;
double salario = 8200.50;
double altura = 1.65;
char genero = 'F';
String nome = "Beatriz Costa";
// Saída de dados.
System.out.println("NOME = " + nome);
System.out.println("IDADE = " + idade);
System.out.println("GENERO = " + genero);
// Usando String.format para formatar a saída com 2 casas decimais.
System.out.println("ALTURA = " + String.format("%.2f", altura));
System.out.println("SALARIO = " + String.format("%.2f", salario));
}
}
🔢 Operadores
Os operadores em Java são herdados de C/C++ e seguem a mesma lógica.
Aritméticos
| Operador | Significado |
|---|---|
+ |
Adição |
- |
Subtração |
* |
Multiplicação |
/ |
Divisão |
% |
Resto da divisão ("mod") |
Comparativos
| Operador | Significado |
|---|---|
< |
Menor |
> |
Maior |
<= |
Menor ou igual |
>= |
Maior ou igual |
== |
Igual |
!= |
Diferente |
Lógicos
| Operador | Significado |
|---|---|
&& |
E |
|| |
OU |
! |
NÃO |
📥 Entrada de Dados com a Classe Scanner
Para ler dados do teclado em Java, utilizamos a classe Scanner, que deve ser importada da biblioteca java.util.
- Importe a classe:
import java.util.Scanner;. - Crie um objeto Scanner:
Scanner sc = new Scanner(System.in);. - Use os métodos de leitura:
nextInt(): Lê um número inteiro.nextDouble(): Lê um número double.next(): Lê a próxima palavra (até o espaço).nextLine(): Lê a linha inteira de texto.next().charAt(0): Lê uma palavra e pega apenas o primeiro caractere.
- Feche o Scanner:
sc.close();para liberar os recursos do sistema.
Atenção à Quebra de Linha Pendente:
Quando você lê um número (nextInt ou nextDouble), o cursor de leitura para após o número, deixando o "Enter" (\n) no buffer de entrada. Se a próxima leitura for um nextLine(), ele lerá essa quebra de linha vazia.
Solução: Consuma a quebra de linha pendente com um sc.nextLine() extra antes de ler o texto.
package curso;
import java.util.Locale;
import java.util.Scanner;
public class Programa {
public static void main(String[] args) {
Locale.setDefault(Locale.US);
Scanner sc = new Scanner(System.in);
String nomeCompleto;
int idade;
double salario;
char genero;
System.out.print("Digite seu nome completo: ");
nomeCompleto = sc.nextLine();
System.out.print("Digite sua idade: ");
idade = sc.nextInt();
System.out.print("Digite seu salario: ");
salario = sc.nextDouble();
System.out.print("Digite seu genero (F/M): ");
genero = sc.next().charAt(0);
System.out.println("\n--- DADOS REGISTRADOS ---");
System.out.println("Nome: " + nomeCompleto);
System.out.println("Idade: " + idade);
System.out.println("Salario: " + String.format("%.2f", salario));
System.out.println("Genero: " + genero);
sc.close();
}
}
🔀 Estruturas de Controle
Estrutura Condicional (if-else)
Permite que o programa execute diferentes caminhos com base em condições.
// ... (dentro do método main)
Scanner sc = new Scanner(System.in);
System.out.print("Digite a hora atual (0-23): ");
int hora = sc.nextInt();
if (hora < 12) {
System.out.println("Bom dia!");
} else if (hora < 18) {
System.out.println("Boa tarde!");
} else {
System.out.println("Boa noite!");
}
sc.close();
Estrutura de Repetição while
O bloco de código é executado enquanto a condição for verdadeira.
// ... (dentro do método main)
Scanner sc = new Scanner(System.in);
int numero;
int soma = 0;
System.out.print("Digite um numero (0 para sair): ");
numero = sc.nextInt();
while (numero != 0) {
soma += numero;
System.out.print("Digite outro numero (0 para sair): ");
numero = sc.nextInt();
}
System.out.println("SOMA FINAL = " + soma);
sc.close();
Estrutura de Repetição for
Ideal para laços que precisam ser executados um número específico de vezes.
// ... (dentro do método main)
Scanner sc = new Scanner(System.in);
System.out.print("Quantos numeros serao somados? ");
int N = sc.nextInt();
int soma = 0;
for (int i = 0; i < N; i++) {
System.out.print("Digite o valor #" + (i + 1) + ": ");
int x = sc.nextInt();
soma += x;
}
System.out.println("SOMA = " + soma);
sc.close();
📏 Vetores e Matrizes
Vetores (Arrays)
Em Java, vetores são objetos que armazenam uma coleção de tamanho fixo de elementos do mesmo tipo.
// ... (dentro do método main)
Locale.setDefault(Locale.US);
Scanner sc = new Scanner(System.in);
System.out.print("Quantos numeros voce vai digitar? ");
int N = sc.nextInt();
// Declaração e instanciação do vetor
double[] vetor = new double[N];
for (int i = 0; i < N; i++) {
System.out.print("Digite um numero: ");
vetor[i] = sc.nextDouble();
}
System.out.println("\nNUMEROS DIGITADOS:");
for (int i = 0; i < N; i++) {
System.out.println(String.format("%.1f", vetor[i]));
}
sc.close();
Matrizes (Arrays Bidimensionais)
São vetores de vetores, úteis para representar dados em formato de tabela.
// ... (dentro do método main)
Scanner sc = new Scanner(System.in);
System.out.print("Quantas linhas tera a matriz? ");
int M = sc.nextInt();
System.out.print("Quantas colunas tera a matriz? ");
int N = sc.nextInt();
// Declaração e instanciação da matriz
int[][] matriz = new int[M][N];
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
System.out.print("Elemento [" + i + "," + j + "]: ");
matriz[i][j] = sc.nextInt();
}
}
System.out.println("\nMATRIZ DIGITADA:");
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
System.out.print(matriz[i][j] + " ");
}
System.out.println(); // Pula para a próxima linha
}
sc.close();
🐞 Depuração (Debugging) em Java
Depurar é o processo de encontrar e corrigir bugs no seu código. Tanto o VS Code quanto o IntelliJ IDEA possuem excelentes ferramentas de depuração visual. Os comandos do material original eram para o Eclipse.
Debugging no VS Code e IntelliJ IDEA
Os conceitos são os mesmos, apenas os atalhos podem variar.
- Habilitar/Desabilitar Breakpoint: Clique na margem à esquerda do número da linha onde você quer que a execução pause.
- Iniciar o Debug:
- IntelliJ: Pressione
Shift + F9ou clique no ícone de inseto ao lado da configuração de execução. - VS Code: Pressione
F5ou vá para a aba "Run and Debug" e inicie a sessão.
- IntelliJ: Pressione
- Controlar a Execução:
- Step Over (Passar por cima): Executa a linha atual e para na próxima. (F8 no IntelliJ, F10 no VS Code).
- Continue (Continuar): Continua a execução até o próximo breakpoint ou o fim do programa. (F9 no IntelliJ, F5 no VS Code).
- Inspecionar Variáveis: A aba "Debug" em ambas as IDEs mostrará uma janela "Variables" onde você pode ver e monitorar o valor das variáveis em tempo real.
ricardotecpro.github.io
Linguagem C# 💎
Bem-vindo ao guia de C# (pronuncia-se "C Sharp"), uma linguagem de programação moderna, orientada a objetos e desenvolvida pela Microsoft. Ela é a principal linguagem da plataforma .NET, sendo amplamente utilizada para criar aplicações web, jogos (com a engine Unity), serviços de backend, aplicações desktop e muito mais.
🛠️ Instalação e Configuração do Ambiente
Para começar a desenvolver em C#, você precisa do .NET SDK (Software Development Kit), que inclui o compilador, bibliotecas e o runtime.
-
Instale o .NET SDK:
- Faça o download da versão mais recente (ou de uma versão LTS - Long-Term Support) do .NET SDK no site oficial da Microsoft.
- Execute o instalador, que já configurará o
Pathdo sistema automaticamente. - Para verificar a instalação, abra um novo terminal e digite
dotnet --version.
-
Escolha uma IDE (Ambiente de Desenvolvimento Integrado): O material original focava no Visual Studio 2019, mas vamos abordar as opções mais modernas.
Opção 1: Visual Studio Community (Recomendado)
- Baixe o Visual Studio Community (versão gratuita para estudantes e desenvolvedores individuais).
- Durante a instalação, na aba "Workloads", selecione a carga de trabalho ".NET desktop development" para garantir que todas as ferramentas para C# sejam instaladas.
Opção 2: Visual Studio Code
- Instale o Visual Studio Code.
- Na aba de extensões, instale o pacote "C# Dev Kit" da Microsoft. Ele fornece um ambiente leve e poderoso para o desenvolvimento .NET.
🚀 Seu Primeiro Programa em C#
A estrutura de um programa C# é organizada em namespaces e classes.
// Importa o namespace System, que contém funcionalidades essenciais como o Console.
using System;
// Namespace é usado para organizar o código e evitar conflitos de nomes.
namespace CursoCSharp
{
// A classe é um contêiner para dados e métodos.
class Program
{
// O método Main é o ponto de entrada de qualquer aplicação C#.
static void Main(string[] args)
{
// Imprime uma linha de texto no console.
Console.WriteLine("Ola, Universo C#!");
}
}
}
Nota sobre C# Moderno: Versões recentes do C# introduziram "top-level statements", que permitem escrever código simples diretamente em um arquivo, sem a necessidade de declarar explicitamente a classe Program e o método Main. Isso é ótimo para iniciantes e scripts rápidos.
📊 Tipos de Dados e Variáveis
Os tipos de dados em C# são robustos e bem definidos.
| Significado | Tipo em C# | Valor Padrão | Observação |
|---|---|---|---|
| Número Inteiro | int |
0 | Tipo padrão para inteiros de 32 bits. Para números maiores, use long (64 bits). |
| Número de Ponto Flutuante | double |
0.0 | Tipo padrão para números reais com precisão dupla. |
| Um Único Caractere | char |
'\0' |
Armazena um caractere Unicode, sempre entre aspas simples. |
| Texto | string |
null |
Um tipo por referência para sequências de caracteres, declarado com aspas duplas. |
| Valor Lógico | bool |
false |
Aceita apenas os valores true ou false. |
📝 Declaração e Atribuição de Variáveis
A declaração e atribuição de variáveis em C# é direta. Para formatação de texto, C# se destaca com a interpolação de strings, que é uma forma mais limpa e legível de construir strings com variáveis.
using System;
using System.Globalization; // Necessário para usar o CultureInfo.
namespace CursoCSharp
{
class Program
{
static void Main(string[] args)
{
// Declaração e inicialização de variáveis.
int idade = 42;
double salario = 9500.75;
double altura = 1.78;
char genero = 'M';
string nome = "Lucas Almeida";
// Usando interpolação de string ($) para uma saída mais limpa.
Console.WriteLine($"NOME = {nome}");
Console.WriteLine($"IDADE = {idade}");
Console.WriteLine($"GENERO = {genero}");
// A formatação de casas decimais é feita com :F2 dentro das chaves.
Console.WriteLine($"ALTURA = {altura:F2}");
// Para garantir o ponto como separador decimal, usa-se CultureInfo.InvariantCulture.
Console.WriteLine($"SALARIO = {salario.ToString("F2", CultureInfo.InvariantCulture)}");
}
}
}
🔢 Operadores
Os operadores em C# são os mesmos encontrados em Java, C e C++, seguindo a mesma precedência e significado.
Aritméticos
| Operador | Significado |
|---|---|
+ |
Adição |
- |
Subtração |
* |
Multiplicação |
/ |
Divisão |
% |
Resto da divisão ("mod") |
Comparativos
| Operador | Significado |
|---|---|
< |
Menor que |
> |
Maior que |
<= |
Menor ou igual a |
>= |
Maior ou igual a |
== |
Igual a |
!= |
Diferente de |
Lógicos
| Operador | Significado |
|---|---|
&& |
E |
|| |
OU |
! |
NÃO |
📥 Entrada de Dados
Em C#, a entrada de dados pelo console é feita com Console.ReadLine(). Este método sempre retorna os dados como uma string. Portanto, é necessário converter (fazer o parse) essa string para o tipo de dado desejado.
- Converter para
int:int.Parse(Console.ReadLine()) - Converter para
double:double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture) - Converter para
char:char.Parse(Console.ReadLine())
O uso de CultureInfo.InvariantCulture ao converter para double é uma boa prática para garantir que o programa interprete o ponto (.) como separador decimal, independentemente da configuração regional do sistema operacional.
using System;
using System.Globalization;
namespace CursoCSharp
{
class Program
{
static void Main(string[] args)
{
string nomeCompleto;
int idade;
double salario;
char genero;
Console.Write("Digite seu nome completo: ");
nomeCompleto = Console.ReadLine(); // Lê a linha inteira como string.
Console.Write("Digite sua idade: ");
idade = int.Parse(Console.ReadLine()); // Lê a string e converte para int.
Console.Write("Digite seu salario: ");
// Lê a string e converte para double, usando o ponto como separador.
salario = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
Console.Write("Digite seu genero (F/M): ");
genero = char.Parse(Console.ReadLine()); // Lê a string e converte para char.
Console.WriteLine("\n--- DADOS REGISTRADOS ---");
Console.WriteLine($"Nome: {nomeCompleto}");
Console.WriteLine($"Idade: {idade}");
Console.WriteLine($"Salario: {salario.ToString("F2", CultureInfo.InvariantCulture)}");
Console.WriteLine($"Genero: {genero}");
}
}
}
🔀 Estruturas de Controle
Estrutura Condicional (if-else)
Permite a execução de código com base em uma ou mais condições.
// ... (dentro do método Main)
Console.Write("Digite a hora atual (0-23): ");
int hora = int.Parse(Console.ReadLine());
if (hora < 12)
{
Console.WriteLine("Bom dia!");
}
else if (hora < 18)
{
Console.WriteLine("Boa tarde!");
}
else
{
Console.WriteLine("Boa noite!");
}
Estrutura de Repetição while
Executa um bloco de código repetidamente enquanto uma condição for verdadeira.
// ... (dentro do método Main)
Console.Write("Digite um numero (0 para sair): ");
int numero = int.Parse(Console.ReadLine());
int soma = 0;
while (numero != 0)
{
soma = soma + numero;
Console.Write("Digite outro numero (0 para sair): ");
numero = int.Parse(Console.ReadLine());
}
Console.WriteLine($"SOMA FINAL = {soma}");
Estrutura de Repetição for
Ideal para laços com um número de iterações predefinido.
// ... (dentro do método Main)
Console.Write("Quantos numeros voce quer somar? ");
int N = int.Parse(Console.ReadLine());
int soma = 0;
for (int i = 0; i < N; i++)
{
Console.Write($"Digite o valor #{i + 1}: ");
int valor = int.Parse(Console.ReadLine());
soma = soma + valor;
}
Console.WriteLine($"SOMA = {soma}");
📏 Vetores e Matrizes
Vetores (Arrays)
Em C#, vetores são coleções de tamanho fixo de um mesmo tipo de dado.
// ... (dentro do método Main)
Console.Write("Quantos numeros voce vai digitar? ");
int N = int.Parse(Console.ReadLine());
// Declaração e instanciação de um vetor de doubles com N posições.
double[] vetor = new double[N];
for (int i = 0; i < N; i++)
{
Console.Write($"Digite o numero #{i + 1}: ");
vetor[i] = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
}
Console.WriteLine("\nNUMEROS DIGITADOS:");
for (int i = 0; i < N; i++)
{
Console.WriteLine(vetor[i].ToString("F1", CultureInfo.InvariantCulture));
}
Matrizes (Arrays Bidimensionais)
C# tem uma sintaxe própria e simplificada para matrizes, usando uma vírgula para separar as dimensões.
// ... (dentro do método Main)
Console.Write("Quantas linhas tera a matriz? ");
int M = int.Parse(Console.ReadLine());
Console.Write("Quantas colunas tera a matriz? ");
int N = int.Parse(Console.ReadLine());
// Declaração e instanciação de uma matriz M x N.
int[,] matriz = new int[M, N];
for (int i = 0; i < M; i++)
{
for (int j = 0; j < N; j++)
{
Console.Write($"Elemento [{i},{j}]: ");
matriz[i, j] = int.Parse(Console.ReadLine());
}
}
Console.WriteLine("\nMATRIZ DIGITADA:");
for (int i = 0; i < M; i++)
{
for (int j = 0; j < N; j++)
{
Console.Write(matriz[i, j] + " ");
}
Console.WriteLine(); // Pula para a próxima linha.
}
🐞 Depuração (Debugging) em C#
Depurar código C# é uma tarefa facilitada pelas excelentes ferramentas disponíveis no Visual Studio e no VS Code.
Debugging no Visual Studio e VS Code
Os atalhos e conceitos são muito semelhantes e padronizados.
- Habilitar/Desabilitar Breakpoint: Pressione
F9na linha desejada para criar um ponto de parada. - Iniciar o Debug: Pressione
F5para iniciar o programa em modo de depuração. A execução pausará no primeiro breakpoint encontrado. - Controlar a Execução:
- Step Over (Passar por cima): Pressione
F10para executar a linha atual e parar na próxima. - Stop (Parar): Pressione
Shift + F5para encerrar a sessão de depuração.
- Step Over (Passar por cima): Pressione
- Inspecionar Variáveis: Na parte inferior da tela, abas como "Locals" (Variáveis Locais) no Visual Studio ou a janela "VARIABLES" no VS Code exibirão os valores atuais das variáveis, permitindo que você os monitore em tempo real.
ricardotecpro.github.io
Linguagem Python 🐍
Bem-vindo ao guia de Python, uma linguagem de programação de alto nível, conhecida por sua sintaxe limpa, legibilidade e vasta gama de aplicações, que vão desde desenvolvimento web e automação de scripts até ciência de dados e inteligência artificial. Sua filosofia incentiva a escrita de código claro e conciso.
🛠️ Instalação e Configuração do Ambiente
Para programar em Python, você precisa do interpretador da linguagem e de um bom editor de código ou IDE.
-
Instale o Python:
- Faça o download da versão mais recente do Python diretamente do site oficial.
- Importante (para Windows): Na primeira tela do instalador, marque a caixa de seleção "Add Python to PATH". Isso permite que você execute o Python a partir de qualquer terminal.
- Para testar a instalação, abra um terminal e digite
pythonoupython3. Você deverá ver o prompt do interpretador Python (>>>). Para sair, digiteexit()e pressione Enter.
-
Escolha uma IDE (Ambiente de Desenvolvimento Integrado): O material original foca no PyCharm, que é excelente. O VS Code é outra alternativa extremamente popular.
Opção 1: PyCharm Community Edition
- Baixe o PyCharm Community. É uma IDE gratuita e poderosa, desenvolvida pela JetBrains e totalmente dedicada ao desenvolvimento em Python, com ótimas ferramentas de depuração e análise de código.
Opção 2: Visual Studio Code
- Instale o Visual Studio Code.
- Na aba de extensões, instale a extensão "Python" da Microsoft. Ela transforma o VS Code em um ambiente de desenvolvimento Python completo, com suporte a depuração, linting e notebooks Jupyter.
🚀 Seu Primeiro Programa em Python
A simplicidade do Python brilha desde o início. Um programa "Olá, Mundo" é apenas uma linha de código.
Diferente de linguagens como Java ou C#, Python não exige uma estrutura complexa de classes ou métodos main para programas simples.
📊 Tipos de Dados e Variáveis
Python é uma linguagem de tipagem dinâmica, o que significa que você não precisa declarar o tipo de uma variável. O tipo é inferido automaticamente quando você atribui um valor a ela.
| Significado | Tipo em Python | Observação |
|---|---|---|
| Número Inteiro | int |
Pode armazenar números de tamanho virtualmente ilimitado. |
| Número de Ponto Flutuante | float |
Usado para números reais (com casas decimais). |
| Texto (String) | str |
Não há um tipo char separado; um caractere é uma str de tamanho 1. Pode ser declarado com aspas simples ('...') ou duplas ("..."). |
| Valor Lógico | bool |
Aceita apenas os valores True ou False (com a primeira letra maiúscula). |
Nota sobre Type Hints (Dicas de Tipo):
Embora a tipagem seja dinâmica, o Python moderno suporta "type hints", que permitem anotar o tipo esperado de uma variável (ex: idade: int = 31). Isso não afeta a execução, mas melhora a legibilidade e ajuda ferramentas de análise de código a encontrar erros.
📝 Declaração e Formatação de Saída
A atribuição de variáveis é direta. Para exibir dados formatados, a melhor abordagem é usar f-strings, que permitem incorporar expressões e variáveis diretamente dentro de uma string.
# A anotação de tipo (ex: : int) é opcional, mas uma boa prática.
idade: int = 31
salario: float = 7800.25
altura: float = 1.72
genero: str = 'F'
nome: str = "Sofia Oliveira"
# f-strings (formatted string literals) são a forma moderna de formatar saídas.
print(f"NOME = {nome}")
print(f"IDADE = {idade}")
print(f"GENERO = {genero}")
# Para formatar um float com 2 casas decimais, usa-se :.2f
print(f"SALARIO = {salario:.2f}")
print(f"ALTURA = {altura:.2f}")
🔢 Operadores
Aritméticos
| Operador | Significado |
|---|---|
+ |
Adição |
- |
Subtração |
* |
Multiplicação |
/ |
Divisão (resulta em float) |
// |
Divisão inteira (resulta em int, descarta o resto) |
% |
Resto da divisão (módulo) |
** |
Exponenciação |
Comparativos
| Operador | Significado |
|---|---|
== |
Igual a |
!= |
Diferente de |
> |
Maior que |
< |
Menor que |
>= |
Maior ou igual a |
<= |
Menor ou igual a |
Lógicos
Em Python, os operadores lógicos são palavras em inglês, o que torna o código muito legível.
| Operador | Significado |
| :---: | :--- |
| and | E |
| or | OU |
| not | NÃO |
📥 Entrada de Dados
A entrada de dados em Python é feita com a função input().
- A função
input()sempre retorna uma string. - Você deve converter explicitamente o valor para o tipo numérico desejado usando
int()oufloat(). - A função pode receber uma string como argumento, que será exibida ao usuário como um prompt.
# O prompt é passado diretamente para a função input().
nome_completo = input("Digite seu nome completo: ")
idade = int(input("Digite sua idade: ")) # Converte a entrada para inteiro.
salario = float(input("Digite seu salario: ")) # Converte a entrada para float.
print("\n--- DADOS REGISTRADOS ---")
print(f"Nome: {nome_completo}")
print(f"Idade: {idade}")
print(f"Salario: {salario:.2f}")
🔀 Estruturas de Controle e a Importância da Indentação
Em Python, os blocos de código (corpo de um if, for, while, etc.) não são definidos por chaves {}. Em vez disso, eles são definidos pela indentação (geralmente 4 espaços). Isso força um estilo de código limpo e organizado.
Estrutura Condicional (if/elif/else)
A estrutura if avalia uma condição. elif (contração de "else if") permite testar múltiplas condições, e else captura todos os outros casos.
hora = int(input("Digite uma hora do dia (0-23): "))
if hora < 12:
print("Bom dia!")
elif hora < 18:
print("Boa tarde!")
else:
print("Boa noite!")
Estrutura de Repetição while
O laço while executa um bloco de código enquanto uma condição for verdadeira.
soma = 0
numero = int(input("Digite um numero (0 para sair): "))
while numero != 0:
soma = soma + numero
numero = int(input("Digite outro numero (0 para sair): "))
print(f"SOMA FINAL = {soma}")
Estrutura de Repetição for
O laço for em Python é usado para iterar sobre uma sequência (como uma lista, uma string ou um range). A função range(start, stop) gera uma sequência de números, que é ideal para laços com contagem.
n = int(input("Quantos numeros voce quer somar? "))
soma = 0
for i in range(0, n):
valor = int(input(f"Digite o valor #{i + 1}: "))
soma = soma + valor
print(f"SOMA = {soma}")
📏 Vetores e Matrizes (Listas)
O tipo de dado em Python que mais se assemelha a um vetor ou array é a lista (list). Listas são coleções ordenadas e mutáveis de itens.
Vetores (Listas)
Uma forma "pythônica" de inicializar uma lista com valores padrão é usando list comprehension.
n = int(input("Quantos numeros voce vai digitar? "))
# Inicializa uma lista com N posições, todas contendo 0.0
# Esta sintaxe é chamada de "list comprehension".
vetor: [float] = [0.0 for x in range(n)]
for i in range(0, n):
vetor[i] = float(input(f"Digite o numero #{i + 1}: "))
print("\nNUMEROS DIGITADOS:")
for numero in vetor:
print(f"{numero:.1f}")
Matrizes (Listas de Listas)
Uma matriz em Python é implementada como uma lista onde cada elemento é, por sua vez, outra lista.
m = int(input("Quantas linhas tera a matriz? "))
n = int(input("Quantas colunas tera a matriz? "))
# Inicializa uma matriz M x N com zeros usando "nested list comprehension".
matriz: [[int]] = [[0 for x in range(n)] for x in range(m)]
for i in range(0, m):
for j in range(0, n):
matriz[i][j] = int(input(f"Elemento [{i},{j}]: "))
print("\nMATRIZ DIGITADA:")
for i in range(0, m):
for j in range(0, n):
print(f"{matriz[i][j]} ", end="")
print() # Pula para a próxima linha
🐞 Depuração (Debugging) em Python
Tanto o PyCharm quanto o VS Code oferecem depuradores visuais excelentes.
Debugging no PyCharm e VS Code
Os conceitos e atalhos são muito parecidos.
- Habilitar/Desabilitar Breakpoint: Clique na margem à esquerda do número da linha onde quer que a execução pause. No PyCharm, o atalho é
Ctrl + F8. - Iniciar o Debug:
- PyCharm: Pressione
Shift + F9ou clique no ícone de inseto. - VS Code: Pressione
F5ou vá para a aba "Run and Debug".
- PyCharm: Pressione
- Controlar a Execução:
- Step Over (Passar por cima): Executa a linha atual e para na próxima. O atalho costuma ser
F8no PyCharm eF10no VS Code.
- Step Over (Passar por cima): Executa a linha atual e para na próxima. O atalho costuma ser
- Inspecionar Variáveis: A aba "Debugger" no PyCharm ou a janela "VARIABLES" no VS Code mostrarão os valores das variáveis em tempo real.
ricardotecpro.github.io
Linguagem JavaScript 📜
Bem-vindo ao guia de JavaScript (JS), a linguagem de programação que impulsiona a web. Originalmente criada para adicionar interatividade às páginas da internet, hoje o JavaScript é uma linguagem multifuncional que roda em navegadores, servidores (com Node.js), aplicativos mobile e muito mais, sendo uma das tecnologias mais importantes e demandadas do mercado.
🛠️ Instalação e Configuração do Ambiente
Uma das grandes vantagens do JavaScript é que ele não exige uma instalação complexa para começar. Ele possui dois ambientes de execução principais:
-
Navegador Web (Browser):
- Instalação: Nenhuma! Todo navegador moderno (Chrome, Firefox, Edge) já possui um motor JavaScript integrado.
- Como usar: Pressione a tecla
F12em qualquer página da web para abrir as Ferramentas de Desenvolvedor e vá para a aba "Console". Você pode escrever e executar código JavaScript diretamente ali.
-
Node.js (Fora do Navegador):
- Instalação: Para rodar JavaScript no seu computador (para criar servidores, scripts de automação, etc.), você precisa do Node.js. Baixe a versão LTS do site oficial. O instalador já inclui o
npm(Node Package Manager), que é usado para gerenciar bibliotecas. - Como usar: Após instalar, você pode criar um arquivo (ex:
meu_programa.js) e executá-lo no terminal com o comando:node meu_programa.js.
- Instalação: Para rodar JavaScript no seu computador (para criar servidores, scripts de automação, etc.), você precisa do Node.js. Baixe a versão LTS do site oficial. O instalador já inclui o
IDE (Ambiente de Desenvolvimento Integrado)
- Visual Studio Code (Recomendado): O VS Code é a escolha principal para desenvolvimento JavaScript. Ele oferece suporte nativo excelente, além de extensões poderosas como "Prettier" para formatação de código e "ESLint" para encontrar erros e forçar boas práticas.
🚀 Seu Primeiro Programa em JavaScript
Vamos ver como executar um "Olá, Mundo!" nos dois ambientes.
No Console do Navegador ou em um arquivo com Node.js:
console.log() é a função universal para imprimir informações no console, seja no navegador ou no terminal do Node.js.
📊 Tipos de Dados e Variáveis
JavaScript é uma linguagem de tipagem dinâmica, assim como Python. O tipo de uma variável é determinado pelo valor que ela recebe. Para declarar variáveis, usamos as palavras-chave let (para valores que podem mudar) e const (para valores constantes).
| Significado | Tipo em JavaScript | Observação |
|---|---|---|
| Número | number |
Usado tanto para inteiros quanto para números de ponto flutuante. Não há distinção entre int e float. |
| Texto | string |
Para sequências de caracteres. Pode ser declarado com aspas simples ('...'), duplas ("...") ou crases (`...`). |
| Valor Lógico | boolean |
Aceita apenas os valores true ou false. |
| Nulo Intencional | null |
Representa a ausência intencional de um valor de objeto. |
| Não Definido | undefined |
Uma variável que foi declarada, mas ainda não teve um valor atribuído. |
| Objeto | object |
Usado para coleções de dados mais complexas e é a base para quase tudo em JS. |
📝 Declaração e Formatação de Saída
Para construir strings com variáveis, a forma mais moderna e legível é usar Template Literals, que são strings declaradas entre crases (`) e permitem a interpolação de variáveis com ${...}.
// Usamos 'let' para variáveis que podem ser alteradas e 'const' para constantes.
const nome = "Gabriel Lima"; //
let idade = 22; //
let salario = 5500.99; //
let isEstudante = true; //
// Usando Template Literals para uma saída limpa e formatada.
console.log(`NOME = ${nome}`); //
console.log(`IDADE = ${idade}`); //
console.log(`SALARIO = ${salario.toFixed(2)}`); // O método .toFixed(2) formata o número para 2 casas decimais.
console.log(`É ESTUDANTE? = ${isEstudante}`); //
🔢 Operadores
Aritméticos
| Operador | Significado |
|---|---|
+ |
Adição |
- |
Subtração |
* |
Multiplicação |
/ |
Divisão |
% |
Resto da divisão (módulo) |
** |
Exponenciação |
Comparativos
| Operador | Significado |
|---|---|
== |
Igual (compara apenas o valor, pode converter o tipo) |
=== |
Estritamente igual (compara o valor E o tipo) |
!= |
Diferente |
!== |
Estritamente diferente |
> |
Maior que |
< |
Menor que |
>= |
Maior ou igual a |
<= |
Menor ou igual a |
Importante: Em JavaScript, prefira sempre usar a comparação estrita (=== e !==). Isso evita bugs inesperados causados pela conversão automática de tipos que o == faz (por exemplo, 7 == "7" é true, mas 7 === "7" é false).
Lógicos
| Operador | Significado |
|---|---|
&& |
E |
|| |
OU |
! |
NÃO |
📥 Entrada de Dados
A forma de receber dados do usuário varia conforme o ambiente de execução.
No Navegador
No navegador, a maneira mais simples de pedir uma informação ao usuário é com a função prompt().
// prompt() exibe uma caixa de diálogo e sempre retorna uma string.
let nome = prompt("Digite seu nome:");
let idade = parseInt(prompt("Digite sua idade:")); // parseInt() converte a string para um número inteiro.
let altura = parseFloat(prompt("Digite sua altura:")); // parseFloat() converte para número com decimais.
console.log(`Olá, ${nome}! Você tem ${idade} anos e ${altura}m de altura.`);
No Node.js
Para ler dados de forma síncrona no terminal com Node.js (semelhante a outras linguagens), podemos usar uma biblioteca externa. Uma opção simples para iniciantes é a readline-sync.
- Instale a biblioteca: No seu terminal, execute
npm install readline-sync. - Use no seu código:
// Importa a biblioteca instalada.
const readline = require('readline-sync');
// Usa os métodos para fazer perguntas e ler as respostas.
const nome = readline.question("Digite seu nome: ");
const idade = readline.questionInt("Digite sua idade: ");
const salario = readline.questionFloat("Digite seu salario: ");
console.log("\n--- DADOS REGISTRADOS ---");
console.log(`Nome: ${nome}`);
console.log(`Idade: ${idade}`);
console.log(`Salario: ${salario.toFixed(2)}`);
🔀 Estruturas de Controle
JavaScript usa chaves {} para delimitar blocos de código, de forma similar a C, Java e C#.
Estrutura Condicional (if/else if/else)
const hora = new Date().getHours(); // Pega a hora atual do sistema.
if (hora < 12) {
console.log("Bom dia!"); //
} else if (hora < 18) {
console.log("Boa tarde!");
} else {
console.log("Boa noite!"); //
}
Estrutura de Repetição while
let soma = 0;
// No Node.js com readline-sync
let numero = require('readline-sync').questionInt("Digite um numero (0 para sair): ");
while (numero !== 0) {
soma = soma + numero;
numero = require('readline-sync').questionInt("Digite outro numero (0 para sair): ");
}
console.log(`SOMA FINAL = ${soma}`);
Estrutura de Repetição for
O laço for clássico é idêntico ao de C/Java/C#.
const n = require('readline-sync').questionInt("Quantos numeros voce quer somar? ");
let soma = 0;
for (let i = 0; i < n; i++) {
let valor = require('readline-sync').questionInt(`Digite o valor #${i + 1}: `);
soma += valor;
}
console.log(`SOMA = ${soma}`);
📏 Vetores e Matrizes (Arrays)
O Array em JavaScript é uma estrutura de dados extremamente versátil e dinâmica, que pode crescer e diminuir de tamanho.
Vetores (Arrays)
const n = require('readline-sync').questionInt("Quantos numeros voce vai digitar? ");
const vetor = []; // Declara um array vazio.
for (let i = 0; i < n; i++) {
let numero = require('readline-sync').questionFloat(`Digite o numero #${i + 1}: `);
vetor.push(numero); // .push() adiciona um elemento ao final do array.
}
console.log("\nNUMEROS DIGITADOS:");
for (let i = 0; i < vetor.length; i++) {
console.log(vetor[i].toFixed(1));
}
Matrizes (Arrays de Arrays)
Uma matriz em JavaScript é um array cujos elementos são outros arrays.
const m = require('readline-sync').questionInt("Quantas linhas tera a matriz? ");
const n = require('readline-sync').questionInt("Quantas colunas tera a matriz? ");
const matriz = [];
for (let i = 0; i < m; i++) {
matriz[i] = []; // Cria uma linha (um array vazio)
for (let j = 0; j < n; j++) {
matriz[i][j] = require('readline-sync').questionInt(`Elemento [${i},${j}]: `);
}
}
console.log("\nMATRIZ DIGITADA:");
for (let i = 0; i < m; i++) {
console.log(matriz[i].join(' ')); // .join(' ') une os elementos da linha com um espaço.
}
🐞 Depuração (Debugging) em JavaScript
Debugging no Navegador
- Abra a página e pressione
F12para abrir as Ferramentas de Desenvolvedor. - Vá para a aba Sources (Fontes).
- Encontre seu arquivo
.jsna lista de arquivos. - Clique na margem esquerda, ao lado do número da linha, para adicionar um breakpoint (ponto de parada).
- Atualize a página ou execute a ação que dispara o código. A execução pausará no seu breakpoint, permitindo que você inspecione variáveis.
Debugging no VS Code (com Node.js)
- Abra seu arquivo
.js. - Clique na margem à esquerda de uma linha para adicionar um breakpoint.
- Pressione
F5para iniciar o depurador. Se for a primeira vez, o VS Code pode pedir para você selecionar o ambiente (escolha Node.js). - A execução pausará no breakpoint, e você poderá inspecionar variáveis, controlar a execução (com
F10para passar por cima) e ver a pilha de chamadas no painel esquerdo.
ricardotecpro.github.io
Linguagem Rust 🦀
Bem-vindo ao guia da linguagem Rust, uma linguagem de programação de sistemas focada em três objetivos principais: segurança, velocidade e concorrência. Rust alcança segurança de memória sem a necessidade de um garbage collector (coletor de lixo), utilizando um sistema inovador de propriedade (ownership) e empréstimo (borrowing). Isso permite que Rust seja tão rápido quanto C/C++, mas com garantias de segurança que previnem classes inteiras de bugs.
🛠️ Instalação e Configuração do Ambiente
O ecossistema de Rust é gerenciado pela ferramenta rustup, que instala o compilador (rustc), o gerenciador de pacotes e build (cargo) e a documentação.
-
Instale o Rust:
- Visite o site oficial do Rust e siga as instruções para o seu sistema operacional. O comando fornecido no site baixa e executa o script
rustup-init, que cuida de toda a instalação. rustupirá configurar automaticamente oPATHdo sistema. Após a instalação, abra um novo terminal e verifique as versões comrustc --versionecargo --version.
- Visite o site oficial do Rust e siga as instruções para o seu sistema operacional. O comando fornecido no site baixa e executa o script
-
Escolha uma IDE (Ambiente de Desenvolvimento Integrado):
Opção 1: Visual Studio Code (Recomendado)
- Instale o Visual Studio Code.
- Na aba de extensões, instale a extensão
rust-analyzer. Ela oferece um suporte de primeira linha para Rust, com autocompletar, análise de código em tempo real e integração com ocargo.
Opção 2: CLion com o plugin Rust
🚀 Seu Primeiro Programa em Rust
A ferramenta cargo facilita a criação e gerenciamento de projetos.
- Crie um novo projeto: No terminal, execute
cargo new ola_rust. - Entre no diretório:
cd ola_rust. - O
cargocria um arquivosrc/main.rscom o seguinte conteúdo:
// A função main() é o ponto de entrada de todo programa executável em Rust.
fn main() {
// println! é uma macro (indicado pela '!') que imprime texto no console.
println!("Olá, Universo Rust!");
}
- Compile e execute o projeto: No terminal, dentro do diretório do projeto, execute
cargo run.
📊 Tipos de Dados e Variáveis
Rust é uma linguagem estaticamente e fortemente tipada. Uma de suas características mais importantes é a imutabilidade por padrão.
- Imutabilidade: Variáveis declaradas com
letsão imutáveis. Para torná-las mutáveis, você deve usar a palavra-chavemut.
| Significado | Tipo em Rust | Observação |
|---|---|---|
| Número Inteiro | i32 |
Tipo inteiro de 32 bits com sinal. Outros tipos incluem i8, i64, u8 (sem sinal), etc. |
| Número de Ponto Flutuante | f64 |
Padrão para números reais, com precisão dupla de 64 bits. |
| Texto (String) | String |
Um tipo de string que pode crescer e ser modificado, alocado na heap. &str é uma "fatia" de string imutável. |
| Valor Lógico | bool |
Aceita apenas os valores true ou false. |
| Um Único Caractere | char |
Representa um único caractere Unicode, declarado com aspas simples. |
📝 Declaração e Formatação de Saída
A declaração de variáveis com let e a formatação com a macro println! são centrais em Rust.
fn main() {
// 'let' cria uma variável imutável.
let nome: &str = "Helena Vargas";
// 'let mut' cria uma variável mutável.
let mut idade: i32 = 29;
let salario: f64 = 14200.50;
let is_gerente: bool = false;
// A formatação é feita com placeholders {} dentro da string.
println!("NOME = {}", nome);
println!("IDADE = {}", idade);
// Para formatar um float com 2 casas decimais, usa-se {:.2}
println!("SALÁRIO = {:.2}", salario);
println!("É GERENTE? = {}", is_gerente);
// Modificando uma variável mutável
idade = 30;
println!("NOVA IDADE = {}", idade);
}
🔢 Operadores
Os operadores em Rust são padrão e seguem a convenção da família C.
Aritméticos
| Operador | Significado |
|---|---|
+ |
Adição |
- |
Subtração |
* |
Multiplicação |
/ |
Divisão |
% |
Resto da divisão (módulo) |
Comparativos
| Operador | Significado |
|---|---|
== |
Igual a |
!= |
Diferente de |
> |
Maior que |
< |
Menor que |
>= |
Maior ou igual a |
<= |
Menor ou igual a |
Lógicos
| Operador | Significado |
|---|---|
&& |
E |
|| |
OU |
! |
NÃO |
📥 Entrada de Dados
A leitura de dados do usuário em Rust é feita através do módulo std::io e exige tratamento de erros explícito. O compilador de Rust ajuda a garantir que você não se esqueça de tratar possíveis falhas.
use std::io; // Importa o módulo de entrada e saída.
fn main() {
println!("Digite seu nome completo:");
// Declara uma nova String mutável para armazenar a entrada.
let mut nome = String::new();
// Lê a linha da entrada padrão.
io::stdin()
.read_line(&mut nome)
.expect("Falha ao ler a linha"); // .expect() para o programa se ocorrer um erro.
// Remove espaços em branco e a quebra de linha da entrada.
nome = nome.trim().to_string();
println!("Digite sua idade:");
let mut idade_str = String::new();
io::stdin()
.read_line(&mut idade_str)
.expect("Falha ao ler a linha");
// Converte a string para um número, tratando o erro.
let idade: i32 = idade_str
.trim()
.parse()
.expect("Por favor, digite um número!");
println!("\n--- DADOS REGISTRADOS ---");
println!("Nome: {}", nome);
println!("Idade: {}", idade);
}
🔀 Estruturas de Controle
Rust usa chaves {} para delimitar blocos de código.
Estrutura Condicional (if/else if/else)
Em Rust, a condição de um if não precisa de parênteses. Além disso, if é uma expressão, o que significa que pode retornar um valor.
let idade = 29;
// 'if' pode ser usado para atribuir um valor a uma variável.
let status = if idade >= 18 {
"Adulto"
} else {
"Menor de idade"
};
println!("Status: {}", status); // Status: Adulto
Estruturas de Repetição
Rust oferece três tipos de laços:
1. loop (Laço Infinito): Executa para sempre, a menos que seja interrompido por um break.
let mut contador = 0;
loop {
println!("Repetindo...");
contador += 1;
if contador == 3 {
break; // Para o laço
}
}
2. while (Laço Condicional): Executa enquanto uma condição for verdadeira.
let mut numero = 3;
while numero != 0 {
println!("{}!", numero);
numero -= 1;
}
println!("LANÇAR!");
3. for (Laço de Iteração): O mais comum, usado para iterar sobre uma coleção ou um range.
📏 Vetores (Arrays e Vectors)
Assim como Go, Rust distingue entre coleções de tamanho fixo e dinâmico.
- Array: Tamanho fixo, conhecido em tempo de compilação. Ex:
let a: [i32; 3] = [1, 2, 3];. - Vector (
Vec<T>): Uma "lista" que pode crescer e diminuir de tamanho, similar aostd::vectordo C++ ouArrayListdo Java. É a escolha mais comum.
Vectors
fn main() {
// Cria um novo vetor mutável e vazio.
let mut numeros: Vec<i32> = Vec::new();
// Adiciona elementos ao vetor.
numeros.push(10);
numeros.push(20);
numeros.push(30);
println!("Vetor: {:?}", numeros); // {:?} é um formatador de debug.
// Iterando sobre o vetor
for numero in &numeros { // & para emprestar o vetor sem mover a propriedade
println!("Número: {}", numero);
}
}
Matrizes (Vetores de Vetores)
Uma matriz em Rust é tipicamente representada por um vetor, onde cada elemento é outro vetor.
// Uma matriz 2x3
let matriz: Vec<Vec<i32>> = vec![
vec![1, 2, 3],
vec![4, 5, 6],
];
println!("Elemento (1,1): {}", matriz[1][1]); // Acessa o elemento na segunda linha, segunda coluna (valor 5)
🐞 Depuração (Debugging) em Rust
Debugging no VS Code
- Além do
rust-analyzer, instale a extensãoCodeLLDBouC/C++da Microsoft, que fornecem o depurador. - Abra seu projeto
cargono VS Code. - Vá para o seu arquivo
src/main.rse clique na margem à esquerda de uma linha para adicionar um breakpoint. - Pressione
F5. O VS Code usará ocargopara compilar seu programa em modo de depuração e, em seguida, iniciará o depurador. - A execução pausará no breakpoint, permitindo que você inspecione variáveis, execute o código passo a passo (
F10) e utilize o console de depuração.
ricardotecpro.github.io
Aula 16 - Linguagem Dart
🐦 Linguagem Dart
Dart é uma linguagem de programação moderna, flexível e otimizada, desenvolvida pelo Google. É a linguagem utilizada pelo framework Flutter.
📊 Tipos de Dados e Variáveis em Dart
Dart é uma linguagem estaticamente tipada, mas possui um poderoso sistema de inferência de tipo com a palavra-chave var.
var: Declara uma variável cujo tipo é inferido pelo compilador. Uma vez inferido, o tipo não pode mudar.final: Declara uma variável que só pode ser definida uma vez (constante em tempo de execução).const: Declara uma variável que é uma constante em tempo de compilação.
| Significado | Tipo em Dart | Observação |
|---|---|---|
| Número Inteiro | int |
Números inteiros sem parte decimal. |
| Número de Ponto Flutuante | double |
Números com casas decimais. |
| Texto | String |
Uma sequência de caracteres, declarada com aspas simples ou duplas. |
| Valor Lógico | bool |
Aceita apenas os valores true ou false. |
| Listas (Arrays) | List |
Uma coleção ordenada de itens. Ex: List<int>. |
| Mapas | Map |
Uma coleção de pares chave-valor. Ex: Map<String, int>. |
📝 Declaração e Saída de Dados
Em Dart, a interpolação de strings é a maneira mais comum de formatar texto. A função print() é usada para depuração e imprime no console.
// A função print() é usada para depuração e imprime no console de depuração.
void VariaveisExemplo() {
final String nome = "Rafael Mendes"; // 'final' porque o nome não mudará.
var idade = 25; // O tipo 'int' é inferido.
var altura = 1.80; // O tipo 'double' é inferido.
var isDesenvolvedor = true; // O tipo 'bool' é inferido.
// Usando interpolação de string ($) para formatar a saída.
print('NOME = $nome');
print('IDADE = $idade');
// Para formatar um double, podemos usar o método .toStringAsFixed().
print('ALTURA = ${altura.toStringAsFixed(2)}');
print('É DESENVOLVEDOR? = $isDesenvolvedor');
}
🔢 Operadores
Operadores Aritméticos
| Operador | Significado |
|---|---|
+ |
Adição |
- |
Subtração |
* |
Multiplicação |
/ |
Divisão |
~/ |
Divisão inteira |
% |
Resto da divisão (módulo) |
Operadores de Igualdade e Relacionais
| Operador | Significado |
|---|---|
== |
Igual a |
!= |
Diferente de |
> |
Maior que |
< |
Menor que |
>= |
Maior ou igual a |
<= |
Menor ou igual a |
Operadores Lógicos
| Operador | Significado |
|---|---|
&& |
E |
|| |
OU |
! |
NÃO |
Operadores Especiais de Dart
??(Null Coalescing):var nome = nomeDoUsuario ?? "Convidado";(SenomeDoUsuariofor nulo, use "Convidado").?.(Null-aware access):print(usuario?.email);(Acesseemailsomente seusuarionão for nulo, senão retornenull).
🔀 Estruturas de Controle
Estrutura Condicional (if/else)
var idade = 25;
if (idade >= 18) {
print("É maior de idade.");
} else {
print("É menor de idade.");
}
Estruturas de Repetição
for (Laço Clássico):
for-in (Para Coleções):
📏 Estruturas de Dados (Listas e Mapas)
Listas
As listas em Dart são o equivalente a arrays ou vetores.
// Cria uma lista de inteiros.
var numeros = <int>[10, 20, 30];
// Adiciona um novo elemento.
numeros.add(40);
// Acessa um elemento pelo índice.
print(numeros[1]); // Imprime 20
Mapas
Mapas são coleções de pares chave-valor.
var pontuacoes = <String, int>{
'Rafael': 100,
'Helena': 95,
};
// Adiciona um novo par.
pontuacoes['Gabriel'] = 98;
// Acessa um valor pela chave.
print(pontuacoes['Rafael']); // Imprime 100
ricardotecpro.github.io
Materiais
Materiais
Bem-vindo à seção de materiais complementares do curso. Aqui você encontra recursos adicionais para apoiar seus estudos.
-
- Acesse os slides de todas as aulas para revisão.
-
- Pratique com listas de exercícios para cada módulo.
-
- Teste seus conhecimentos com quizzes interativos.
-
- Desenvolva projetos práticos para aplicar o que aprendeu.
-
- Guias de instalação e configuração do ambiente.
Slides
Slides das Aulas
Aqui você encontra os slides apresentados em cada aula, prontos para revisão ou apresentação.
-
Módulo 1 – Conceitos Básicos
-
Módulo 2 – Trabalhando com GitHub
-
Módulo 3 – Fluxos e Organização
-
Módulo 4 – Colaboração e Carreira
Como Usar
- Os slides usam RevealJS para interatividade.
- Clique nos links acima para abrir em tela cheia.
- Use as setas do teclado (⬅️ ➡️) para navegar.
- Pressione
Fpara entrar em modo tela cheia.
Exercícios
Exercícios
Bem-vindo à seção de exercícios! Aqui você encontra listas de exercícios práticos para cada aula do curso.
-
Módulo 1 – Conceitos Básicos
-
Módulo 2 – Trabalhando com GitHub
-
Módulo 3 – Fluxos e Organização
-
Módulo 4 – Colaboração e Carreira
Dicas
- Tente resolver os exercícios sem consultar a solução
- Pratique regularmente para fixar o conteúdo
- Não tenha medo de errar, faz parte do aprendizado!
Exercícios - Aula 01: Conteúdo do Curso
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Conteúdo do Curso.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Conteúdo do Curso.
- Teste com diferentes entradas.
Exercícios - Aula 02: Introdução à Programação
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Introdução à Programação.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Introdução à Programação.
- Teste com diferentes entradas.
Exercícios - Aula 03: Estrutura Sequencial
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Estrutura Sequencial.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Estrutura Sequencial.
- Teste com diferentes entradas.
Exercícios - Aula 04: Estrutura Condicional
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Estrutura Condicional.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Estrutura Condicional.
- Teste com diferentes entradas.
Exercícios - Aula 05: Estruturas Repetitivas
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Estruturas Repetitivas.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Estruturas Repetitivas.
- Teste com diferentes entradas.
Exercícios - Aula 06: Vetores
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Vetores.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Vetores.
- Teste com diferentes entradas.
Exercícios - Aula 07: Matrizes
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Matrizes.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Matrizes.
- Teste com diferentes entradas.
Exercícios - Aula 08: Funções
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Funções.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Funções.
- Teste com diferentes entradas.
Exercícios - Aula 09: Linguagem C
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Linguagem C.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Linguagem C.
- Teste com diferentes entradas.
Exercícios - Aula 10: Linguagem C++
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Linguagem C++.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Linguagem C++.
- Teste com diferentes entradas.
Exercícios - Aula 11: Linguagem Java
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Linguagem Java.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Linguagem Java.
- Teste com diferentes entradas.
Exercícios - Aula 12: Linguagem C
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Linguagem C#.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Linguagem C#.
- Teste com diferentes entradas.
Exercícios - Aula 13: Linguagem Python
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Linguagem Python.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Linguagem Python.
- Teste com diferentes entradas.
Exercícios - Aula 14: Linguagem JavaScript
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Linguagem JavaScript.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Linguagem JavaScript.
- Teste com diferentes entradas.
Exercícios - Aula 15: Linguagem Rust
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Linguagem Rust.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Linguagem Rust.
- Teste com diferentes entradas.
Exercícios - Aula 16: Linguagem Dart
🛠 Prática
- Exercício Teórico:
-
Explique com suas palavras o conceito de Linguagem Dart.
-
Exercício Prático:
- Implemente um algoritmo simples relacionado a Linguagem Dart.
- Teste com diferentes entradas.
Quizzes
Quizzes Interativos
Teste seus conhecimentos com quizzes interativos para cada aula!
-
Módulo 1 – Conceitos Básicos
-
Módulo 2 – Trabalhando com GitHub
-
Módulo 3 – Fluxos e Organização
-
Módulo 4 – Colaboração e Carreira
🎯 Como Usar
- Responda todas as perguntas antes de verificar o resultado
- Use os quizzes para revisar o conteúdo das aulas
- Refaça os quizzes até acertar 100%!
Quiz 01 - Conteúdo do Curso
Quiz 02 - Introdução à Programação
Quiz 03 - Estrutura Sequencial
Quiz 04 - Estrutura Condicional
Quiz 05 - Estruturas Repetitivas
Quiz 06 - Vetores
Quiz 07 - Matrizes
Quiz 08 - Funções
Quiz 09 - Linguagem C
Quiz 10 - Linguagem C++
Quiz 11 - Linguagem Java
Quiz 12 - Linguagem C
Quiz 13 - Linguagem Python
Quiz 14 - Linguagem JavaScript
Quiz 15 - Linguagem Rust
Quiz 16 - Linguagem Dart
Projetos
Projetos Práticos
Aprenda Git criando um projeto real do zero até a publicação!
-
Módulo 1 – O Início
-
Módulo 2 – GitHub
-
Módulo 3 – Organização
-
Módulo 4 – Publicação
🚀 Sobre o Projeto do Curso
Neste curso, você não fará projetos aleatórios. Você construirá, passo a passo, seu Portfólio Profissional hospedado no GitHub Pages. Cada aula adiciona uma nova camada de conhecimento e funcionalidade ao seu portfólio.
Projeto - Aula 01: Conteúdo do Curso
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Conteúdo do Curso.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Conteúdo do Curso.
Projeto - Aula 02: Introdução à Programação
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Introdução à Programação.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Introdução à Programação.
Projeto - Aula 03: Estrutura Sequencial
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Estrutura Sequencial.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Estrutura Sequencial.
Projeto - Aula 04: Estrutura Condicional
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Estrutura Condicional.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Estrutura Condicional.
Projeto - Aula 05: Estruturas Repetitivas
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Estruturas Repetitivas.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Estruturas Repetitivas.
Projeto - Aula 06: Vetores
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Vetores.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Vetores.
Projeto - Aula 07: Matrizes
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Matrizes.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Matrizes.
Projeto - Aula 08: Funções
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Funções.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Funções.
Projeto - Aula 09: Linguagem C
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Linguagem C.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Linguagem C.
Projeto - Aula 10: Linguagem C++
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Linguagem C++.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Linguagem C++.
Projeto - Aula 11: Linguagem Java
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Linguagem Java.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Linguagem Java.
Projeto - Aula 12: Linguagem C
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Linguagem C#.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Linguagem C#.
Projeto - Aula 13: Linguagem Python
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Linguagem Python.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Linguagem Python.
Projeto - Aula 14: Linguagem JavaScript
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Linguagem JavaScript.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Linguagem JavaScript.
Projeto - Aula 15: Linguagem Rust
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Linguagem Rust.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Linguagem Rust.
Projeto - Aula 16: Linguagem Dart
🚀 Desafio
Desenvolva um pequeno projeto aplicando os conceitos de Linguagem Dart.
Requisitos:
- Deve utilizar o conceito principal da aula.
- Deve ser funcional e compilável/executável.
- Documente seu código.
Sugestão:
Crie um programa que resolva um problema do cotidiano usando Linguagem Dart.
Configuração
Configuração do Ambiente
Guias para preparar seu computador para o curso.
🛠️ O que você vai precisar?
Módulo 1: Lógica de Programação
Para aprender algoritmos, usamos ferramentas didáticas: - VisualG ou Portugol Studio: Ambientes leves para praticar lógica em português.
Módulo 2: Linguagens de Programação
Para programar profissionalmente, você precisará de compiladores e IDEs: - Compiladores e IDEs: Instalação de C, C++, Java, Python, VS Code, etc.
👨🏫 VisualG e Portugol: O Primeiro Passo na Lógica de Programação
O VisualG é um software educacional amplamente utilizado no Brasil e em outros países de língua portuguesa como uma ferramenta para o ensino e aprendizado de lógica de programação e algoritmos. Ele funciona como um editor e interpretador para uma linguagem de pseudocódigo chamada Portugol.
Desenvolvido pelo professor Cláudio de Castro Monteiro, da Universidade de Franca (UNIFRAN), seu principal objetivo é remover as barreiras sintáticas complexas das linguagens de programação "reais" (como C++, Java ou Python), permitindo que o estudante iniciante se concentre exclusivamente no desenvolvimento do raciocínio lógico necessário para resolver problemas.
📜 A Linguagem: O Portugol Estruturado
O coração do VisualG é o Portugol, uma pseudolinguagem que utiliza palavras-chave em português para representar as estruturas lógicas da programação. A ideia é criar uma ponte entre a linguagem natural e uma linguagem de programação formal.
As principais características do Portugol no VisualG são:
- Palavras-chave em Português: Comandos como
algoritmo,var,inicio,fimalgoritmo,leia,escreva,se,entao,senao,para,faca,enquanto. - Estrutura Rígida: Todo programa tem uma estrutura bem definida de declaração de algoritmo, seção de variáveis e o bloco de início/fim.
- Tipos de Dados Básicos: Focado nos primitivos essenciais para a lógica:
inteiro,real,caractereelogico. - Simplicidade Intencional: A linguagem é propositalmente limitada, não incluindo conceitos avançados como orientação a objetos, para manter o foco total nos fundamentos da lógica procedural.
🖥️ O Ambiente VisualG
O software em si é um ambiente integrado simples que oferece três funcionalidades principais:
- Editor de Código: Uma área de texto para escrever o algoritmo em Portugol.
- Interpretador: Executa o algoritmo passo a passo, mostrando a saída em um console de texto.
- Visualizador de Variáveis: Este é o recurso didático mais poderoso. Um painel exibe todas as variáveis declaradas e seus valores são atualizados em tempo real à medida que o algoritmo é executado. Isso permite que o aluno "veja" o que está acontecendo na memória do computador, facilitando a compreensão de conceitos como atribuição e estado.
O VisualG funciona, na prática, como um simulador de "teste de mesa" (desk check), uma técnica usada para depurar algoritmos manualmente no papel.
flowchart Estrutura de um Algoritmo no VisualG
Um fluxograma é uma ótima maneira de planejar a lógica de um algoritmo antes de escrevê-lo. O exemplo abaixo mostra o fluxo para calcular a média de um aluno e determinar se ele foi aprovado.
graph TD;
A(Início do Algoritmo) --> B{Declare as variáveis:<br/>nota1, nota2, media: real};
B --> C{Escreva "Digite a primeira nota"};
C --> D[Leia nota1];
D --> E{Escreva "Digite a segunda nota"};
E --> F[Leia nota2];
F --> G[media <- (nota1 + nota2) / 2];
G --> H{media >= 6.0?};
H -- Sim --> I[Escreva "Aprovado"];
H -- Não --> J[Escreva "Reprovado"];
I --> K(Fim do Algoritmo);
J --> K;
style A fill:#cfc,stroke:#333,stroke-width:2px
style K fill:#f99,stroke:#333,stroke-width:2px⌨️ Exemplo Prático: Média de Notas
Este é o código em Portugol, para ser escrito e executado no VisualG, que implementa a lógica do fluxograma acima.
algoritmo "CalculoMedia"
// Descrição: Este algoritmo lê duas notas de um aluno, calcula a média
// e informa se o aluno foi aprovado ou reprovado.
// Autor: [Seu Nome]
// Data: 20/08/2025
var
nota1, nota2, media: real
inicio
// Seção de Comandos
escreva("Digite a primeira nota do aluno: ")
leia(nota1)
escreva("Digite a segunda nota do aluno: ")
leia(nota2)
media <- (nota1 + nota2) / 2
escreval // Pula uma linha para melhor formatação
escreval("A média do aluno é: ", media)
se (media >= 6) entao
escreva("Situação: APROVADO")
senao
escreva("Situação: REPROVADO")
fimse
fimalgoritmo
Ao executar este código no VisualG, o programa irá pedir as duas notas, exibir a média calculada e, em seguida, a situação final do aluno. No painel de variáveis, será possível ver os valores de nota1, nota2 e media durante toda a execução.
🎓 O Papel do VisualG na Jornada do Desenvolvedor
O VisualG é uma ferramenta de entrada, um "andaime" para ajudar a construir as fundações do conhecimento em programação.
Vantagens
- Foco Absoluto na Lógica: Remove a frustração inicial com erros de sintaxe (ponto e vírgula, chaves, etc.), permitindo que o aluno se concentre no que realmente importa no início: a lógica.
- Barreira de Idioma Reduzida: Usar palavras-chave em português diminui a carga cognitiva de ter que aprender os conceitos de programação e um novo idioma (inglês) ao mesmo tempo.
- Visualização do Fluxo: O monitor de variáveis e a execução passo a passo são ferramentas pedagógicas excelentes para visualizar como um programa funciona internamente.
Limitações e Próximos Passos
- Não é uma Ferramenta Profissional: Nenhuma empresa desenvolve software comercial com VisualG. Seu propósito é estritamente didático.
- A Necessária Transição: Após dominar os conceitos de variáveis, condicionais (
se/senao) e laços de repetição (para/enquanto) no VisualG, o aluno está preparado para o próximo passo. A transição para uma linguagem como Python, JavaScript ou Java se torna muito mais suave, pois o desafio passa a ser apenas aprender uma nova sintaxe para aplicar a lógica que já foi compreendida.
💡 Portugol Studio: A Evolução do Aprendizado de Algoritmos
O Portugol Studio é um Ambiente de Aprendizagem Integrado (ILE - Integrated Learning Environment), gratuito e de código aberto, projetado para ensinar os fundamentos da programação e da lógica de algoritmos. Desenvolvido pela Universidade do Vale do Itajaí (UNIVALI), ele representa uma evolução moderna de ferramentas didáticas como o VisualG.
Seu objetivo é o mesmo: fornecer um ambiente em português onde estudantes iniciantes possam se concentrar na lógica, sem as complexidades sintáticas de uma linguagem de programação profissional. No entanto, o Portugol Studio faz isso com uma interface mais rica, recursos mais poderosos e uma abordagem que prepara melhor o aluno para as linguagens de programação do mercado.
🆚 Portugol Studio vs. VisualG: O Que Mudou?
Embora compartilhem a mesma filosofia, o Portugol Studio oferece uma experiência de aprendizado mais moderna e completa.
- IDE Moderna: Oferece recursos comuns em ambientes de desenvolvimento profissionais, como syntax highlighting (coloração de código), autocompletar, sugestões de código e mensagens de erro muito mais claras e detalhadas.
- Recursos Gráficos e Multimídia: Uma das maiores vantagens. O Studio inclui bibliotecas prontas (
inclua Biblioteca Grafico,inclua Biblioteca Som) que permitem ao aluno criar desenhos, animações simples e até pequenos jogos, tornando o aprendizado mais visual, lúdico e engajador. - Melhor Suporte a Funções e Modularidade: Facilita a criação de algoritmos mais organizados através de funções, com um suporte mais claro para passagem de parâmetros (por valor e por referência).
- Estrutura de Programa Mais Próxima do "Real": A estrutura
programa { funcao inicio() { ... } }se assemelha mais à estrutura de um programa em linguagens como C, C++ ou Java, com uma função principal (inicio) que serve como ponto de entrada. - Depurador (Debugger) Integrado: Possui um depurador mais avançado que permite a inserção de breakpoints (pontos de parada), tornando a investigação de bugs e o entendimento do fluxo do código mais fáceis.
📜 A Sintaxe do Portugol no Studio
A sintaxe é similar ao Portugol tradicional, mas com uma estrutura mais formal.
- Estrutura do Programa: Todo código é envolvido por um bloco
programa. A execução sempre começa nafuncao inicio(). - Declaração de Variáveis: Os tipos de dados (
inteiro,real,cadeia,caracter,logico) são declarados antes de serem usados. - Entrada e Saída: Os comandos
leia()eescreva()são usados para interagir com o usuário. - Estruturas de Controle: Inclui as estruturas lógicas essenciais:
se/senao,caso/pare,para,enquantoefaca...enquanto. - Funções: Permite a criação de blocos de código reutilizáveis, melhorando a organização.
flowchart Visualizando um Fluxo com Funções
Este fluxograma representa uma calculadora simples, onde a lógica da operação é separada em uma função, demonstrando a modularidade incentivada pelo Portugol Studio.
graph TD;
A(Início) --> B{Leia num1, num2, operacao};
B --> C(Chame a função<br/>calcular(num1, num2, operacao));
subgraph "Função calcular"
D{Avalie 'operacao'};
D -- "+" --> E[resultado = num1 + num2];
D -- "-" --> F[resultado = num1 - num2];
D -- "*" --> G[resultado = num1 * num2];
D -- "/" --> H[resultado = num1 / num2];
E --> I(Retorne resultado);
F --> I;
G --> I;
H --> I;
end
C --> J[Guarde o valor retornado];
J --> K{Escreva o resultado};
K --> L(Fim);
style A fill:#cfc,stroke:#333,stroke-width:2px
style L fill:#f99,stroke:#333,stroke-width:2px⌨️ Exemplo Prático: Calculadora Simples
O código abaixo implementa a lógica do fluxograma no Portugol Studio.
programa
{
funcao inicio()
{
real n1, n2, resultado
caracter operacao
escreva("Digite o primeiro número: ")
leia(n1)
escreva("Digite o segundo número: ")
leia(n2)
escreva("Digite a operação (+, -, *, /): ")
leia(operacao)
resultado = calcular(n1, n2, operacao)
escreva("\nO resultado é: ", resultado)
}
funcao real calcular(real num1, real num2, caracter op)
{
real res = 0.0
escolha (op)
{
caso '+':
res = num1 + num2
pare
caso '-':
res = num1 - num2
pare
caso '*':
res = num1 * num2
pare
caso '/':
se (num2 != 0) {
res = num1 / num2
} senao {
escreva("Erro! Divisão por zero não é permitida.")
}
pare
caso contrario:
escreva("Operação inválida!")
}
retorne res
}
}
🎓 Por Que Começar com o Portugol Studio?
Para um iniciante, o Portugol Studio oferece um ambiente de aprendizado robusto e motivador.
- Ambiente Amigável e Moderno: A interface é mais intuitiva e agradável que a de ferramentas mais antigas, o que melhora a experiência do aluno.
- Feedback Imediato e Claro: As mensagens de erro são detalhadas, ajudando o estudante a entender não apenas o que está errado, mas por que está errado.
- Aprendizado Lúdico e Tangível: A capacidade de criar elementos gráficos e jogos simples torna os conceitos de lógica mais concretos e a experiência de aprendizado muito mais divertida.
- Transição Suave para a Programação "Real": A estrutura de
programaefuncao inicio()introduz de forma natural o conceito de escopo e de um "ponto de entrada" (main), que são fundamentais em linguagens como C, Java e C#.
Em resumo, o Portugol Studio é uma excelente porta de entrada para o mundo da programação, construindo uma base sólida de lógica e resolução de problemas em um ambiente controlado e amigável, antes de o aluno enfrentar as complexidades das linguagens profissionais.
⚖️ VisualG vs. Portugol Studio: Quadro Comparativo de Comandos
A tabela abaixo apresenta uma comparação lado a lado dos principais comandos e estruturas utilizados no VisualG e no Portugol Studio, destacando as diferenças de sintaxe e as evoluções presentes na ferramenta mais moderna.
| Funcionalidade | VisualG | Portugol Studio | Observações |
|---|---|---|---|
| Estrutura do Programa | pascal<br>algoritmo "NomeDoAlgoritmo"<br>var<br> // Variáveis<br>inicio<br> // Comandos<br>fimalgoritmo<br> |
c<br>programa {<br> funcao inicio() {<br> // Comandos<br> }<br>}<br> |
A estrutura do Studio é mais similar à de linguagens como C, Java e JavaScript, com uma função inicio agindo como a main. |
| Declaração de Variáveis | pascal<br>// Todas declaradas no bloco 'var'<br>var<br> nome: caractere<br> idade: inteiro<br> salario: real<br> |
c<br>// Podem ser declaradas em qualquer<br>// lugar antes do primeiro uso<br>cadeia nome<br>inteiro idade<br>real salario<br> |
Studio é mais flexível. O tipo caractere do VisualG (para strings) é chamado de cadeia no Studio. |
| Saída de Dados | escreva("Texto")\<br>escreval("Texto e pula linha") |
escreva("Texto") |
Para pular linha no Studio, usa-se o caractere de escape \n. Ex: escreva("Texto\n"). |
| Entrada de Dados | leia(variavel) |
leia(variavel) |
Praticamente idênticos. |
| Atribuição de Valor | variavel <- valor |
variavel = valor |
O Studio adota o = como padrão, mais comum em linguagens modernas. O <- também é aceito por compatibilidade. |
| Comentários | // Comentário de uma linha |
// Comentário de uma linha\<br>/* Comentário de<br> múltiplas linhas */ |
O Studio oferece suporte a comentários de múltiplas linhas, assim como em C/Java/CSS. |
| Condicional (Se/Senão) | pascal<br>se (cond) entao<br> ...<br>senao<br> ...<br>fimse<br> |
c<br>se (cond) {<br> ...<br>} senao {<br> ...<br>}<br> |
O Studio usa chaves {} para delimitar blocos de código, um padrão visual mais moderno e claro. |
| Laço de Repetição (Para) | pascal<br>para i de 1 ate 10 faca<br> ...<br>fimpara<br> |
c<br>para (inteiro i = 1; i <= 10; i++) {<br> ...<br>}<br> |
A sintaxe do Studio é idêntica à do for em C, Java, C#, o que prepara melhor o aluno para linguagens profissionais. |
| Laço de Repetição (Enquanto) | pascal<br>enquanto (cond) faca<br> ...<br>fimenquanto<br> |
c<br>enquanto (cond) {<br> ...<br>}<br> |
A lógica é a mesma, com a principal diferença sendo o uso de chaves {} no Studio. |
| Laço de Repetição (Faça...Enquanto) | pascal<br>repita<br> ...<br>ate (condicao_de_parada)<br> |
c<br>faca {<br> ...<br>} enquanto (condicao_de_continuacao)<br> |
A sintaxe é diferente e a lógica da condição é invertida: VisualG para quando a condição é VERDADEIRO, Studio continua enquanto for VERDADEIRO. |
| Estrutura de Escolha | pascal<br>escolha (variavel)<br> caso 1<br> ...<br> caso 2<br> ...<br> outrocaso<br> ...<br>fimescolha<br> |
c<br>escolha (variavel) {<br> caso 1:<br> ...<br> pare<br> caso 2:<br> ...<br> pare<br> caso contrario:<br> ...<br>}<br> |
O Studio exige o comando pare (equivalente ao break) para evitar que a execução continue nos casos seguintes. |
| Funções (com retorno) | pascal<br>Funcao Nome(p1: tipo): tipo_retorno<br>inicio<br> ...<br> retorne valor<br>fimfuncao<br> |
c<br>funcao tipo_retorno Nome(tipo p1) {<br> ...<br> retorne valor<br>}<br> |
A sintaxe do Studio é mais concisa e alinhada com linguagens modernas. |
| Procedimentos (sem retorno) | pascal<br>procedimento Nome(p1: tipo)<br>inicio<br> ...<br>fimprocedimento<br> |
c<br>funcao vazio Nome(tipo p1) {<br> ...<br>}<br> |
No Studio, um procedimento é apenas uma função que retorna o tipo vazio (equivalente ao void). |
| Vetores (Arrays) | meuVetor: vetor [1..10] de inteiro |
inteiro meuVetor[10] |
A declaração no Studio é mais direta. Ambos usam índice baseado em zero por padrão (0 a 9 para um tamanho de 10). |
| Matrizes (Arrays 2D) | minhaMatriz: vetor [1..5, 1..5] de real |
real minhaMatriz[5][5] |
Similar aos vetores, a sintaxe do Studio é mais compacta. |
| Uso de Bibliotecas | Não possui | inclua Biblioteca Grafico\<br>inclua Biblioteca Matematica |
Recurso exclusivo do Portugol Studio que expande enormemente suas capacidades, permitindo a criação de jogos simples, desenhos e uso de funções matemáticas avançadas. |
🛠️ Capítulo: Instalação de Ferramentas de Desenvolvimento
Este guia apresenta o passo a passo para configurar o ambiente de desenvolvimento para as linguagens C, C++, Python, Java e C#, com recomendações atualizadas para um fluxo de trabalho moderno e eficiente.
⚙️ Ambiente para C e C++
Para programar em C e C++, você precisa de um compilador e uma IDE (Ambiente de Desenvolvimento Integrado).
1. Compilador (MinGW-w64)
O GCC é o compilador padrão para C/C++ no mundo open-source. No Windows, a forma mais fácil de instalá-lo é através do projeto MinGW-w64.
Recomendação Moderna: A maneira mais simples é instalar o MinGW através do instalador de um IDE como o Code::Blocks ou configurar o VS Code para gerenciá-lo. Para uma instalação manual:
- Acesse o site oficial do MinGW-w64 e baixe o instalador.
- Durante a instalação, anote o diretório onde os arquivos foram instalados (ex:
C:\MinGW\bin). - Adicione o compilador ao Path do Windows: Isso permite que você execute o compilador de qualquer terminal.
- Pesquise por "Editar as variáveis de ambiente do sistema".
- Clique em "Variáveis de Ambiente...".
- Na seção "Variáveis do sistema", selecione
Pathe clique em "Editar". - Clique em "Novo" e adicione o caminho para a pasta
bindo MinGW (ex:C:\MinGW\bin).
2. IDE
-
Opção Moderna (Recomendado): Visual Studio Code
- Um editor leve e poderoso. Instale a extensão "C/C++ Extension Pack" da Microsoft para obter IntelliSense, depuração e compilação.
-
Opção do Curso Original: Code::Blocks
- Uma IDE tradicional e simples. Ao baixar, escolha a versão que já inclui o compilador MinGW (ex:
codeblocks-xx.xxmingw-setup.exe) para uma instalação mais fácil.
- Uma IDE tradicional e simples. Ao baixar, escolha a versão que já inclui o compilador MinGW (ex:
✅ Primeiro Programa em C e C++
C - "Olá, Mundo!"
C++ - "Olá, Mundo!"
🐍 Ambiente para Python
1. Interpretador Python
- Baixe a versão mais recente do Python diretamente do site oficial:
python.org. - Importante: Na primeira tela da instalação, marque a opção "Add Python to PATH". Isso simplifica a execução de scripts pelo terminal.
2. IDE
-
Opção 1 (Recomendado): Visual Studio Code
- Extremamente popular para Python. Instale a extensão "Python" da Microsoft para obter uma experiência completa.
-
Opção 2: PyCharm Community Edition
- Uma IDE poderosa e dedicada ao desenvolvimento Python, da JetBrains.
✅ Primeiro Programa em Python
☕ Ambiente para Java (Foco em VS Code e IntelliJ)
A configuração do ambiente Java envolve o JDK (Kit de Desenvolvimento Java) e uma IDE.
1. JDK (Java Development Kit)
O JDK é essencial para compilar e executar código Java.
Recomendação Moderna: As IDEs mais modernas, como IntelliJ IDEA e VS Code, podem baixar e gerenciar o JDK para você. Caso queira fazer a instalação manual:
- Baixe uma versão LTS (Long-Term Support) do JDK, como o OpenJDK 17 ou 21.
- Após a instalação, configure as variáveis de ambiente
JAVA_HOMEePathpara apontar para a instalação do JDK.JAVA_HOME:C:\Program Files\Java\jdk-17.0.xPath: Adicionar%JAVA_HOME%\bin
- Teste a instalação no terminal com o comando:
java -version.
2. IDE (Adaptado do Eclipse)
-
Opção 1: Visual Studio Code
- Configuração: Instale a extensão "Extension Pack for Java" da Microsoft. Ela inclui tudo o que é necessário para desenvolver, depurar e testar aplicações Java.
- Criação de Projeto: Use a paleta de comandos (
Ctrl+Shift+P) e digite"Java: Create Java Project"para iniciar um novo projeto com a estrutura de pastas correta.
-
Opção 2: IntelliJ IDEA Community
- Uma das IDEs mais poderosas e inteligentes para Java. A versão Community é gratuita.
- Configuração: Ao criar um novo projeto, o IntelliJ detecta os JDKs instalados ou oferece a opção de baixar um novo automaticamente.
✅ Primeiro Programa em Java
Este código pode ser executado em qualquer uma das IDEs mencionadas.
// Classe renomeada para seguir boas práticas em português
public class Programa {
// O método main é o ponto de entrada da aplicação
public static void main(String[] args) {
System.out.println("Ola mundo, com Java moderno!");
}
}
💻 Ambiente para C#
1. SDK e IDE (Visual Studio)
Para desenvolvimento C# no Windows, a forma mais integrada é usar o Visual Studio.
- Baixe o Visual Studio Community (versão gratuita) do site da Microsoft.
- Durante a instalação, selecione a carga de trabalho (workload) "Desenvolvimento para desktop com .NET". Isso instalará o SDK do .NET e todos os componentes necessários para criar aplicações C#.
Alternativa Multiplataforma: Para Linux, macOS ou para quem prefere um editor mais leve, o VS Code com a extensão "C# Dev Kit" é uma excelente opção.
Dicas para Visual Studio
- Indentar código:
Ctrl + K, Ctrl + D - Rodar sem depuração:
Ctrl + F5 - Ajustar fonte: Segure
Ctrle use o scroll do mouse.
✅ Primeiro Programa em C#
using System;
// Namespace atualizado para um nome genérico
namespace ExemploModerno
{
class Programa
{
static void Main(string[] args)
{
Console.WriteLine("Olá, Mundo com C#!");
}
}
}
ricardotecpro.github.io
Versão para Impressão
Esta página foi gerada automaticamente para impressão.